python_in_R.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Python in R with `reticulate`\n",
    "\n",
    "In this tutorial, we will demonstrate how to perform basic Python operations in R using the library `reticulate`. This includes converting between R and Python dataframe objects and running python functions. Since `scvi-tools` is written in Python, such an interface is necessary to take advantage of these models within the R environment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Attaching SeuratObject\n",
      "\n",
      "Registered S3 method overwritten by 'cli':\n",
      "  method     from         \n",
      "  print.boxx spatstat.geom\n",
      "\n",
      "Warning message in if (is.na(desc)) {:\n",
      "“the condition has length > 1 and only the first element will be used”\n",
      "Warning message in if (is.na(desc)) {:\n",
      "“the condition has length > 1 and only the first element will be used”\n",
      "Warning message in if (is.na(desc)) {:\n",
      "“the condition has length > 1 and only the first element will be used”\n",
      "Warning message in if (is.na(desc)) {:\n",
      "“the condition has length > 1 and only the first element will be used”\n",
      "Warning message in if (is.na(desc)) {:\n",
      "“the condition has length > 1 and only the first element will be used”\n",
      "Warning message in if (is.na(desc)) {:\n",
      "“the condition has length > 1 and only the first element will be used”\n",
      "Warning message in if (is.na(desc)) {:\n",
      "“the condition has length > 1 and only the first element will be used”\n",
      "Warning message in if (is.na(desc)) {:\n",
      "“the condition has length > 1 and only the first element will be used”\n",
      "Warning message in if (is.na(desc)) {:\n",
      "“the condition has length > 1 and only the first element will be used”\n",
      "Warning message in if (is.na(desc)) {:\n",
      "“the condition has length > 1 and only the first element will be used”\n",
      "Warning message in if (is.na(desc)) {:\n",
      "“the condition has length > 1 and only the first element will be used”\n",
      "Warning message in if (is.na(desc)) {:\n",
      "“the condition has length > 1 and only the first element will be used”\n",
      "── \u001b[1mInstalled datasets\u001b[22m ────────────────────────────────────────────────────────────────────────────────────────── SeuratData v0.2.1 ──\n",
      "\n",
      "\u001b[32m✔\u001b[39m \u001b[34mifnb    \u001b[39m 3.0.0                                                  \u001b[32m✔\u001b[39m \u001b[34mstxBrain\u001b[39m 0.1.1\n",
      "\u001b[32m✔\u001b[39m \u001b[34mpbmc3k  \u001b[39m 3.1.4                                                  \n",
      "\n",
      "\n",
      "──────────────────────────────────────────────────────────────── Key ────────────────────────────────────────────────────────────────\n",
      "\n",
      "\u001b[32m✔\u001b[39m Dataset loaded successfully\n",
      "\u001b[33m❯\u001b[39m Dataset built with a newer version of Seurat than installed\n",
      "\u001b[31m❓\u001b[39m Unknown version of Seurat installed\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "library(reticulate)\n",
    "library(anndata)\n",
    "library(sceasy)\n",
    "\n",
    "library(Seurat)\n",
    "library(SeuratData)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operating between Python and R"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we will create a dummy list, and convert between R and Python. Note that R is 1-indexed while Python is 0-indexed, so when retrieiving elements the user should be conscious of what kind of object they are operating on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]]\n",
      "[1] 1\n",
      "\n",
      "[[2]]\n",
      "[1] 2\n",
      "\n",
      "[[3]]\n",
      "[1] 3\n",
      "\n",
      "[1] \"list\"\n"
     ]
    }
   ],
   "source": [
    "lst <- list(1, 2, 3)\n",
    "print(lst)\n",
    "print(typeof(lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will convert this R list to a Python list via a function provided by the `reticulate` library called `r_to_py()`. This works for various fundamental R types like vectors, lists, arrays, data frames, functions, and primitives. Any python object will have `typeof(obj)` as `environment`. To see the Python type, we can call `class(obj)` instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0, 2.0, 3.0]\n",
      "[1] \"environment\"\n",
      "[1] \"python.builtin.list\"   \"python.builtin.object\"\n"
     ]
    }
   ],
   "source": [
    "py_lst <- r_to_py(lst)\n",
    "print(py_lst)\n",
    "print(typeof(py_lst))\n",
    "print(class(py_lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can call instance functions of a Python object by replacing the usual dot notation with `$` instead. So something like `lst.append(5)` would become `lst$append(5)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "None"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0, 2.0, 3.0, 5.0]\n"
     ]
    }
   ],
   "source": [
    "py_lst$append(5)\n",
    "print(py_lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note, arguments passed into these functions can either be Python or R objects. R objects passed in as arguments will automatically converted to the corresponding Python type via the `r_to_py()` function. However, this can sometimes result in unexpected results. For example, `0` in R will be automatically inferred as a float, which can result in an error when trying to pop an element below. We workaround this by explictly casting the R term to an integer with `as.integer(0)` or using the `0L` syntax, which results in the proper type conversion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "Error in py_call_impl(callable, dots$args, dots$keywords): TypeError: integer argument expected, got float\n",
     "output_type": "error",
     "traceback": [
      "Error in py_call_impl(callable, dots$args, dots$keywords): TypeError: integer argument expected, got float\nTraceback:\n",
      "1. py_lst$pop(0)",
      "2. py_call_impl(callable, dots$args, dots$keywords)"
     ]
    }
   ],
   "source": [
    "# This will fail.\n",
    "py_lst$pop(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.0, 3.0, 5.0]\n"
     ]
    }
   ],
   "source": [
    "py_lst$pop(0L)\n",
    "print(py_lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we will convert back into an R list with the function `py_to_r()` which executes the inverse of `r_to_py()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1] 2 3 5\n"
     ]
    }
   ],
   "source": [
    "lst <- py_to_r(py_lst)\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import Python libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we load the scanpy library via reticulate using the `import()` function. The `convert` boolean argument determines whether the output of Python functions is automatically converted to an R object equivalent via the `py_to_r()` function. Here, we set it to `FALSE` intentionally since often times we would like to retain the Python format for further manipulation in Python (e.g. with scanpy). Additionally, this keeps data type conversion more explicit, avoiding type confusion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc <- import('scanpy', convert = FALSE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Dataset with SeuratData"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "data(\"pbmc3k\")\n",
    "pbmc <- pbmc3k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "An object of class Seurat \n",
       "13714 features across 2700 samples within 1 assay \n",
       "Active assay: RNA (13714 features, 0 variable features)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pbmc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to make use of `scvi-tools`, we use a third-party library called `sceasy` to convert the SeuratObject into an AnnData object, the primary format used by `scanpy` and `scvi-tools`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AnnData object with n_obs × n_vars = 2700 × 13714\n",
       "    obs: 'orig.ident', 'nCount_RNA', 'nFeature_RNA', 'seurat_annotations'\n",
       "    var: 'name'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "adata <- convertFormat(pbmc, from=\"seurat\", to=\"anndata\", main_layer=\"counts\", drop_single_values=FALSE)\n",
    "adata"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access the AnnData fields in the same way we call instance functions, with the `$` syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "               orig.ident  nCount_RNA  nFeature_RNA seurat_annotations\n",
       "AAACATACAACCAC     pbmc3k      2419.0           779       Memory CD4 T\n",
       "AAACATTGAGCTAC     pbmc3k      4903.0          1352                  B\n",
       "AAACATTGATCAGC     pbmc3k      3147.0          1129       Memory CD4 T\n",
       "AAACCGTGCTTCCG     pbmc3k      2639.0           960         CD14+ Mono\n",
       "AAACCGTGTATGCG     pbmc3k       980.0           521                 NK"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "adata$obs$head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>'pandas.core.frame.DataFrame'</li><li>'pandas.core.generic.NDFrame'</li><li>'pandas.core.base.PandasObject'</li><li>'pandas.core.accessor.DirNamesMixin'</li><li>'pandas.core.base.SelectionMixin'</li><li>'pandas.core.indexing.IndexingMixin'</li><li>'pandas.core.arraylike.OpsMixin'</li><li>'python.builtin.object'</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'pandas.core.frame.DataFrame'\n",
       "\\item 'pandas.core.generic.NDFrame'\n",
       "\\item 'pandas.core.base.PandasObject'\n",
       "\\item 'pandas.core.accessor.DirNamesMixin'\n",
       "\\item 'pandas.core.base.SelectionMixin'\n",
       "\\item 'pandas.core.indexing.IndexingMixin'\n",
       "\\item 'pandas.core.arraylike.OpsMixin'\n",
       "\\item 'python.builtin.object'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'pandas.core.frame.DataFrame'\n",
       "2. 'pandas.core.generic.NDFrame'\n",
       "3. 'pandas.core.base.PandasObject'\n",
       "4. 'pandas.core.accessor.DirNamesMixin'\n",
       "5. 'pandas.core.base.SelectionMixin'\n",
       "6. 'pandas.core.indexing.IndexingMixin'\n",
       "7. 'pandas.core.arraylike.OpsMixin'\n",
       "8. 'python.builtin.object'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"pandas.core.frame.DataFrame\"        \"pandas.core.generic.NDFrame\"       \n",
       "[3] \"pandas.core.base.PandasObject\"      \"pandas.core.accessor.DirNamesMixin\"\n",
       "[5] \"pandas.core.base.SelectionMixin\"    \"pandas.core.indexing.IndexingMixin\"\n",
       "[7] \"pandas.core.arraylike.OpsMixin\"     \"python.builtin.object\"             "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class(adata$obs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<caption>A data.frame: 6 × 4</caption>\n",
       "<thead>\n",
       "\t<tr><th></th><th scope=col>orig.ident</th><th scope=col>nCount_RNA</th><th scope=col>nFeature_RNA</th><th scope=col>seurat_annotations</th></tr>\n",
       "\t<tr><th></th><th scope=col>&lt;fct&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;int&gt;</th><th scope=col>&lt;fct&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><th scope=row>AAACATACAACCAC</th><td>pbmc3k</td><td>2419</td><td> 779</td><td>Memory CD4 T</td></tr>\n",
       "\t<tr><th scope=row>AAACATTGAGCTAC</th><td>pbmc3k</td><td>4903</td><td>1352</td><td>B           </td></tr>\n",
       "\t<tr><th scope=row>AAACATTGATCAGC</th><td>pbmc3k</td><td>3147</td><td>1129</td><td>Memory CD4 T</td></tr>\n",
       "\t<tr><th scope=row>AAACCGTGCTTCCG</th><td>pbmc3k</td><td>2639</td><td> 960</td><td>CD14+ Mono  </td></tr>\n",
       "\t<tr><th scope=row>AAACCGTGTATGCG</th><td>pbmc3k</td><td> 980</td><td> 521</td><td>NK          </td></tr>\n",
       "\t<tr><th scope=row>AAACGCACTGGTAC</th><td>pbmc3k</td><td>2163</td><td> 781</td><td>Memory CD4 T</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 6 × 4\n",
       "\\begin{tabular}{r|llll}\n",
       "  & orig.ident & nCount\\_RNA & nFeature\\_RNA & seurat\\_annotations\\\\\n",
       "  & <fct> & <dbl> & <int> & <fct>\\\\\n",
       "\\hline\n",
       "\tAAACATACAACCAC & pbmc3k & 2419 &  779 & Memory CD4 T\\\\\n",
       "\tAAACATTGAGCTAC & pbmc3k & 4903 & 1352 & B           \\\\\n",
       "\tAAACATTGATCAGC & pbmc3k & 3147 & 1129 & Memory CD4 T\\\\\n",
       "\tAAACCGTGCTTCCG & pbmc3k & 2639 &  960 & CD14+ Mono  \\\\\n",
       "\tAAACCGTGTATGCG & pbmc3k &  980 &  521 & NK          \\\\\n",
       "\tAAACGCACTGGTAC & pbmc3k & 2163 &  781 & Memory CD4 T\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 6 × 4\n",
       "\n",
       "| <!--/--> | orig.ident &lt;fct&gt; | nCount_RNA &lt;dbl&gt; | nFeature_RNA &lt;int&gt; | seurat_annotations &lt;fct&gt; |\n",
       "|---|---|---|---|---|\n",
       "| AAACATACAACCAC | pbmc3k | 2419 |  779 | Memory CD4 T |\n",
       "| AAACATTGAGCTAC | pbmc3k | 4903 | 1352 | B            |\n",
       "| AAACATTGATCAGC | pbmc3k | 3147 | 1129 | Memory CD4 T |\n",
       "| AAACCGTGCTTCCG | pbmc3k | 2639 |  960 | CD14+ Mono   |\n",
       "| AAACCGTGTATGCG | pbmc3k |  980 |  521 | NK           |\n",
       "| AAACGCACTGGTAC | pbmc3k | 2163 |  781 | Memory CD4 T |\n",
       "\n"
      ],
      "text/plain": [
       "               orig.ident nCount_RNA nFeature_RNA seurat_annotations\n",
       "AAACATACAACCAC pbmc3k     2419        779         Memory CD4 T      \n",
       "AAACATTGAGCTAC pbmc3k     4903       1352         B                 \n",
       "AAACATTGATCAGC pbmc3k     3147       1129         Memory CD4 T      \n",
       "AAACCGTGCTTCCG pbmc3k     2639        960         CD14+ Mono        \n",
       "AAACCGTGTATGCG pbmc3k      980        521         NK                \n",
       "AAACGCACTGGTAC pbmc3k     2163        781         Memory CD4 T      "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "head(py_to_r(adata$obs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, we loaded the `anndata` R library. It is important to know when dealing with a Python AnnData object and an R AnnDataR6 Object. We can distinguish these by using the `class()` method, then using the `py_to_r(), r_to_py()` functions to interoperate between the two. Generally, it is recommended to use the R AnnDataR6 object to manipulate fields."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>'anndata._core.anndata.AnnData'</li><li>'python.builtin.object'</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'anndata.\\_core.anndata.AnnData'\n",
       "\\item 'python.builtin.object'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'anndata._core.anndata.AnnData'\n",
       "2. 'python.builtin.object'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"anndata._core.anndata.AnnData\" \"python.builtin.object\"        "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class(adata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".list-inline {list-style: none; margin:0; padding: 0}\n",
       ".list-inline>li {display: inline-block}\n",
       ".list-inline>li:not(:last-child)::after {content: \"\\00b7\"; padding: 0 .5ex}\n",
       "</style>\n",
       "<ol class=list-inline><li>'AnnDataR6'</li><li>'R6'</li></ol>\n"
      ],
      "text/latex": [
       "\\begin{enumerate*}\n",
       "\\item 'AnnDataR6'\n",
       "\\item 'R6'\n",
       "\\end{enumerate*}\n"
      ],
      "text/markdown": [
       "1. 'AnnDataR6'\n",
       "2. 'R6'\n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "[1] \"AnnDataR6\" \"R6\"       "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class(py_to_r(adata))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert adata object to R AnnDataR6 object.\n",
    "adata <- py_to_r(adata)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can set fields in the AnnData object using the `$` syntax. Here, we run CPM normalization using scanpy and save it to a new layer in the AnnData object. For the sake of demonstration, we do not use the inplace update option that scanpy provides. Note, this only works well if using the AnnDataR6 object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_norm <- sc$pp$normalize_total(adata, target_sum = 1e+09, inplace = FALSE)[\"X\"]\n",
    "adata$layers[\"X_norm\"] <- X_norm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<caption>A data.frame: 6 × 13714</caption>\n",
       "<thead>\n",
       "\t<tr><th></th><th scope=col>AL627309.1</th><th scope=col>AP006222.2</th><th scope=col>RP11-206L10.2</th><th scope=col>RP11-206L10.9</th><th scope=col>LINC00115</th><th scope=col>NOC2L</th><th scope=col>KLHL17</th><th scope=col>PLEKHN1</th><th scope=col>RP11-54O7.17</th><th scope=col>HES4</th><th scope=col>⋯</th><th scope=col>MT-ND4L</th><th scope=col>MT-ND4</th><th scope=col>MT-ND5</th><th scope=col>MT-ND6</th><th scope=col>MT-CYB</th><th scope=col>AC145212.1</th><th scope=col>AL592183.1</th><th scope=col>AL354822.1</th><th scope=col>PNRC2.1</th><th scope=col>SRSF10.1</th></tr>\n",
       "\t<tr><th></th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>⋯</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><th scope=row>AAACATACAACCAC</th><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>⋯</td><td>     0.0</td><td>4133939.5</td><td> 413393.9</td><td>0</td><td>1653575.8</td><td>0</td><td>     0.0</td><td>0</td><td>0</td><td>0</td></tr>\n",
       "\t<tr><th scope=row>AAACATTGAGCTAC</th><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>⋯</td><td>     0.0</td><td>6730573.5</td><td> 203956.8</td><td>0</td><td>1631654.1</td><td>0</td><td>203956.8</td><td>0</td><td>0</td><td>0</td></tr>\n",
       "\t<tr><th scope=row>AAACATTGATCAGC</th><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>⋯</td><td>     0.0</td><td> 953288.9</td><td> 635525.9</td><td>0</td><td>1271051.9</td><td>0</td><td>     0.0</td><td>0</td><td>0</td><td>0</td></tr>\n",
       "\t<tr><th scope=row>AAACCGTGCTTCCG</th><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>⋯</td><td>378931.4</td><td>1136794.2</td><td> 757862.8</td><td>0</td><td> 757862.8</td><td>0</td><td>     0.0</td><td>0</td><td>0</td><td>0</td></tr>\n",
       "\t<tr><th scope=row>AAACCGTGTATGCG</th><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>⋯</td><td>     0.0</td><td>      0.0</td><td>2040816.4</td><td>0</td><td>1020408.2</td><td>0</td><td>     0.0</td><td>0</td><td>0</td><td>0</td></tr>\n",
       "\t<tr><th scope=row>AAACGCACTGGTAC</th><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td><td>⋯</td><td>     0.0</td><td>1849283.4</td><td>      0.0</td><td>0</td><td>1386962.5</td><td>0</td><td>     0.0</td><td>0</td><td>0</td><td>0</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 6 × 13714\n",
       "\\begin{tabular}{r|lllllllllllllllllllll}\n",
       "  & AL627309.1 & AP006222.2 & RP11-206L10.2 & RP11-206L10.9 & LINC00115 & NOC2L & KLHL17 & PLEKHN1 & RP11-54O7.17 & HES4 & ⋯ & MT-ND4L & MT-ND4 & MT-ND5 & MT-ND6 & MT-CYB & AC145212.1 & AL592183.1 & AL354822.1 & PNRC2.1 & SRSF10.1\\\\\n",
       "  & <dbl> & <dbl> & <dbl> & <dbl> & <dbl> & <dbl> & <dbl> & <dbl> & <dbl> & <dbl> & ⋯ & <dbl> & <dbl> & <dbl> & <dbl> & <dbl> & <dbl> & <dbl> & <dbl> & <dbl> & <dbl>\\\\\n",
       "\\hline\n",
       "\tAAACATACAACCAC & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & ⋯ &      0.0 & 4133939.5 &  413393.9 & 0 & 1653575.8 & 0 &      0.0 & 0 & 0 & 0\\\\\n",
       "\tAAACATTGAGCTAC & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & ⋯ &      0.0 & 6730573.5 &  203956.8 & 0 & 1631654.1 & 0 & 203956.8 & 0 & 0 & 0\\\\\n",
       "\tAAACATTGATCAGC & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & ⋯ &      0.0 &  953288.9 &  635525.9 & 0 & 1271051.9 & 0 &      0.0 & 0 & 0 & 0\\\\\n",
       "\tAAACCGTGCTTCCG & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & ⋯ & 378931.4 & 1136794.2 &  757862.8 & 0 &  757862.8 & 0 &      0.0 & 0 & 0 & 0\\\\\n",
       "\tAAACCGTGTATGCG & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & ⋯ &      0.0 &       0.0 & 2040816.4 & 0 & 1020408.2 & 0 &      0.0 & 0 & 0 & 0\\\\\n",
       "\tAAACGCACTGGTAC & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & ⋯ &      0.0 & 1849283.4 &       0.0 & 0 & 1386962.5 & 0 &      0.0 & 0 & 0 & 0\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 6 × 13714\n",
       "\n",
       "| <!--/--> | AL627309.1 &lt;dbl&gt; | AP006222.2 &lt;dbl&gt; | RP11-206L10.2 &lt;dbl&gt; | RP11-206L10.9 &lt;dbl&gt; | LINC00115 &lt;dbl&gt; | NOC2L &lt;dbl&gt; | KLHL17 &lt;dbl&gt; | PLEKHN1 &lt;dbl&gt; | RP11-54O7.17 &lt;dbl&gt; | HES4 &lt;dbl&gt; | ⋯ ⋯ | MT-ND4L &lt;dbl&gt; | MT-ND4 &lt;dbl&gt; | MT-ND5 &lt;dbl&gt; | MT-ND6 &lt;dbl&gt; | MT-CYB &lt;dbl&gt; | AC145212.1 &lt;dbl&gt; | AL592183.1 &lt;dbl&gt; | AL354822.1 &lt;dbl&gt; | PNRC2.1 &lt;dbl&gt; | SRSF10.1 &lt;dbl&gt; |\n",
       "|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|\n",
       "| AAACATACAACCAC | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ⋯ |      0.0 | 4133939.5 |  413393.9 | 0 | 1653575.8 | 0 |      0.0 | 0 | 0 | 0 |\n",
       "| AAACATTGAGCTAC | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ⋯ |      0.0 | 6730573.5 |  203956.8 | 0 | 1631654.1 | 0 | 203956.8 | 0 | 0 | 0 |\n",
       "| AAACATTGATCAGC | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ⋯ |      0.0 |  953288.9 |  635525.9 | 0 | 1271051.9 | 0 |      0.0 | 0 | 0 | 0 |\n",
       "| AAACCGTGCTTCCG | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ⋯ | 378931.4 | 1136794.2 |  757862.8 | 0 |  757862.8 | 0 |      0.0 | 0 | 0 | 0 |\n",
       "| AAACCGTGTATGCG | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ⋯ |      0.0 |       0.0 | 2040816.4 | 0 | 1020408.2 | 0 |      0.0 | 0 | 0 | 0 |\n",
       "| AAACGCACTGGTAC | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ⋯ |      0.0 | 1849283.4 |       0.0 | 0 | 1386962.5 | 0 |      0.0 | 0 | 0 | 0 |\n",
       "\n"
      ],
      "text/plain": [
       "               AL627309.1 AP006222.2 RP11-206L10.2 RP11-206L10.9 LINC00115\n",
       "AAACATACAACCAC 0          0          0             0             0        \n",
       "AAACATTGAGCTAC 0          0          0             0             0        \n",
       "AAACATTGATCAGC 0          0          0             0             0        \n",
       "AAACCGTGCTTCCG 0          0          0             0             0        \n",
       "AAACCGTGTATGCG 0          0          0             0             0        \n",
       "AAACGCACTGGTAC 0          0          0             0             0        \n",
       "               NOC2L KLHL17 PLEKHN1 RP11-54O7.17 HES4 ⋯ MT-ND4L  MT-ND4   \n",
       "AAACATACAACCAC 0     0      0       0            0    ⋯      0.0 4133939.5\n",
       "AAACATTGAGCTAC 0     0      0       0            0    ⋯      0.0 6730573.5\n",
       "AAACATTGATCAGC 0     0      0       0            0    ⋯      0.0  953288.9\n",
       "AAACCGTGCTTCCG 0     0      0       0            0    ⋯ 378931.4 1136794.2\n",
       "AAACCGTGTATGCG 0     0      0       0            0    ⋯      0.0       0.0\n",
       "AAACGCACTGGTAC 0     0      0       0            0    ⋯      0.0 1849283.4\n",
       "               MT-ND5    MT-ND6 MT-CYB    AC145212.1 AL592183.1 AL354822.1\n",
       "AAACATACAACCAC  413393.9 0      1653575.8 0               0.0   0         \n",
       "AAACATTGAGCTAC  203956.8 0      1631654.1 0          203956.8   0         \n",
       "AAACATTGATCAGC  635525.9 0      1271051.9 0               0.0   0         \n",
       "AAACCGTGCTTCCG  757862.8 0       757862.8 0               0.0   0         \n",
       "AAACCGTGTATGCG 2040816.4 0      1020408.2 0               0.0   0         \n",
       "AAACGCACTGGTAC       0.0 0      1386962.5 0               0.0   0         \n",
       "               PNRC2.1 SRSF10.1\n",
       "AAACATACAACCAC 0       0       \n",
       "AAACATTGAGCTAC 0       0       \n",
       "AAACATTGATCAGC 0       0       \n",
       "AAACCGTGCTTCCG 0       0       \n",
       "AAACCGTGTATGCG 0       0       \n",
       "AAACGCACTGGTAC 0       0       "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "head(as.data.frame(adata$layers[\"X_norm\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you should be comfortable interoperating between R and Python. Once you configure your AnnData object to contain all the necessary fields for your model of choice, you can intialize and train with the AnnData object. Visit our tutorials page for examples of running `scvi-tools` in R."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Session Info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R version 4.0.3 (2020-10-10)\n",
      "Platform: x86_64-conda-linux-gnu (64-bit)\n",
      "Running under: Ubuntu 16.04.6 LTS\n",
      "\n",
      "Matrix products: default\n",
      "BLAS/LAPACK: /data/yosef2/users/jhong/miniconda3/envs/r_tutorial/lib/libopenblasp-r0.3.12.so\n",
      "\n",
      "attached base packages:\n",
      "[1] stats     graphics  grDevices utils     datasets  methods   base     \n",
      "\n",
      "other attached packages:\n",
      "[1] stxBrain.SeuratData_0.1.1 pbmc3k.SeuratData_3.1.4  \n",
      "[3] ifnb.SeuratData_3.0.0     SeuratData_0.2.1         \n",
      "[5] SeuratObject_4.0.2        Seurat_4.0.4             \n",
      "[7] sceasy_0.0.6              anndata_0.7.5.3          \n",
      "[9] reticulate_1.22          \n"
     ]
    }
   ],
   "source": [
    "sI <- sessionInfo()\n",
    "sI$loadedOnly <- NULL\n",
    "print(sI, locale=FALSE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R r_tutorial",
   "language": "R",
   "name": "r_tutorial"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "4.0.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}