gregoryschwartz/too-many-cells
Cluster single cells and analyze cell clade relationships.
2.8K
gregoryschwartz/too-many-cells repository overview
The JavaScript code in this tag is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License (GNU GPL) as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. The code is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU GPL for more details.
As additional permission under GNU GPL version 3 section 7, you may distribute non-source (e.g., minimized or compacted) forms of that code without the copy of the GNU GPL normally required by section 4, provided you include this license notice and a URL through which recipients can access the Corresponding Source.
@licend The above is the entire license notice for the JavaScript code in this tag. */
function CodeHighlightOn(elem, id) { var target = document.getElementById(id); if(null != target) { elem.cacheClassElem = elem.className; elem.cacheClassTarget = target.className; target.className = "code-highlighted"; elem.className = "code-highlighted"; } } function CodeHighlightOff(elem, id) { var target = document.getElementById(id); if(elem.cacheClassElem) elem.className = elem.cacheClassElem; if(elem.cacheClassTarget) target.className = elem.cacheClassTarget; } /]]>///-->
too-many-cells
Table of Contents
See https://github.com/GregorySchwartz/too-many-cells for latest version.
See the bioRxiv paper for more information about the algorithm.
Description
too-many-cells is a suite of tools, algorithms, and visualizations focusing on
the relationships between cell clades. This includes new ways of clustering,
plotting, choosing differential expression comparisons, and more! While
too-many-cells was intended for single cell RNA-seq, any abundance data in any
domain can be used. Rather than opt for a unique positioning of each cell using
dimensionality reduction approaches like t-SNE, UMAP, and PCA, too-many-cells
recursively divides cells into clusters and relates clusters rather than
individual cells. In fact, by recursively dividing until further dividing would
be considered noise or random partitioning, we can eliminate noisy relationships
at the fine-grain level. The resulting binary tree serves as a basis for a
different perspective of single cells, using our birch-beer visualization
and tree measures to describe simultaneously large and small populations,
without additional parameters or runs. See below for a full list of features.
New features for current version
- A new R wrapper was written to quickly get data to and from
too-many-cellsfrom R. Check it out here! - Now works with Cellranger 3.0 matrices in addition to Cellranger 2.0
- Can prune (make into leaves) specified nodes with
--custom-cut. - Can analyze sets of features averaged together (e.g. gene sets). Breaks API,
so update your
--draw-leaf "DrawItem (DrawContinuous \"Cd4\")"argument to--draw-leaf "DrawItem (DrawContinuous [\"Cd4\"])"(notice the list notation). - Outputs values from differential entry point plots (from
--genes), and can aggregate genes by average.
Installation
We provide multiple ways to install too-many-cells. We recommend installing
stack (see below), but we also have docker images and a Dockerfile to
use in any system in case you have a custom build (for instance, a non-standard
R installation) or difficulty installing. macOS and Windows users:
too-many-cells was built and tested on linux, so we highly recommend using the
docker image (which a completely isolated environment which requires no
compiling or installation, other than docker itself) as there may be
difficulties in installing the dependencies. There are, however, additional
instructions for macOS here if you really want to compile it.
Dependencies
You may require the following dependencies to build and run (from Ubuntu 14.04, use the appropriate packages from your distribution of choice):
- build-essential
- libgmp-dev
- libblas-dev
- liblapack-dev
- libgsl-dev
- libgtk2.0-dev
- libcairo2-dev
- libpango1.0-dev
- graphviz
- r-base
- r-base-dev
To install them, in Ubuntu:
sudo apt install build-essential libgmp-dev libblas-dev liblapack-dev libgsl-dev libgtk2.0-dev libcairo2-dev libpango1.0-dev graphviz r-base r-base-dev
too-many-cells also uses the following packages from R:
- cowplot
- ggplot2
- edgeR
- jsonlite
To install them in R,
install.packages(c("ggplot2", "cowplot", "jsonlite"))
install.packages("BiocManager")
BiocManager::install("edgeR")
Install stack
See https://docs.haskellstack.org/en/stable/README/ for more details.
curl -sSL https://get.haskellstack.org/ | sh
stack setup
Install too-many-cells
Source
Probably the easiest method if you don't want to mess with dependencies (outside of the ones above).
git clone https://github.com/GregorySchwartz/too-many-cells.git
cd too-many-cells
stack install
Online
We only require stack (or cabal), you do not need to download any source
code (but you might need the stack.yaml dependency versions), just run the
following command to place too-many-cells in your ~/.local/bin/:
stack install too-many-cells
If you run into errors like Error: While constructing the build plan, the
following exceptions were encountered:, then follow it's advice. Usually you
just need to follow the suggestion and add the dependencies to the specified
file. For a quick yaml configuration, refer to
https://github.com/GregorySchwartz/too-many-cells/blob/master/stack.yaml. Relies
on eigen-3.3.4.1 right now.
Docker
Different computers have different setups, operating systems, and repositories.
Do put the entire program in a container to bypass difficulties (with the other
methods above), we user docker. So first, install docker.
To get too-many-cells (replace 0.1.5.0 with any version needed):
docker pull gregoryschwartz/too-many-cells:0.1.5.0
To run too-many-cells in a docker container:
sudo docker run gregoryschwartz/too-many-cells:0.1.5.0 -h
Docker won't be able to find your files by default. You need to mount the
folders with -v in order to have docker read and write from and to the
filesystem, respectively. Read the documentation about volumes for more
information. Essentially, -v /path/to/matrix/on/host:/input_matrix with -m
/input_matrix is what you want, where before the : is on the host filesystem
while after the : is what the docker program sees. Then you can write the
output in the same way: -v /path/to/output/on/host:/output will write the
output to the folder before the :.
To build the too-many-cells image yourself if you want:
git clone https://github.com/GregorySchwartz/too-many-cells.git
cd too-many-cells
docker build -t too-many-cells -f ./Dockerfile .
macOS
We recommend using docker on macOS. If you need to build too-many-cells, you
should get the above dependencies. For some dependencies, you can use brewer,
then install too-many-cells (in the cloned folder, don't forget to install the
R dependencies above):
brew cask install xquartz
brew install glib cairo gtk gettext fontconfig freetype
brew tap brewsci/bio
brew tap brewsci/science
brew install r zeromq graphviz pkg-config gsl libffi gobject-introspection gtk+ gtk+3
# Needed so pkg-config and libraries can be found.
# For the second path, use the ouput of "brew info libffi".
export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:/usr/local/opt/libffi/lib/pkgconfig
# Tell gtk that it's quartz
stack install --flag gtk:have-quartz-gtk
Troubleshooting
I am getting errors like AesonException "Error in $.packages.cassava.constraints.flags... when running stack commands
Try upgrading stack with stack upgrade. The new installation will be in
~/.local/bin, so use that binary.
I use conda or custom ld library locations and I cannot install too-many-cells or run into weird R errors
stack and too-many-cells assume system libraries and programs. To solve this
issue, first install the dependencies above at the system level, including
system R. Then to every stack and too-many-cells command, prepend
PATH="$HOME/.local/bin:/usr/bin:$PATH" to all commands. For instance:
PATH="$HOME/.local/bin:/usr/bin:$PATH" stack installPATH="$HOME/.local/bin:/usr/bin:$PATH" too-many-cells make-tree -h
If your shared libraries are abnormal and use libR.so from non-system
locations, be sure to also have
Tag summary
Content type
Image
Digest
sha256:cf1c39f64…
Size
1.7 GB
Last updated
almost 4 years ago
docker pull gregoryschwartz/too-many-cells:cli-entry