Seurat - Guided Clustering Tutorial

Compiled: August 30, 2021

<small class="dont-index" style="box-sizing: border-box; font-size: 12.9px;">Source: vignettes/pbmc3k_tutorial.Rmd</small>

Setup the Seurat Object

For this tutorial, we will be analyzing the a dataset of Peripheral Blood Mononuclear Cells (PBMC) freely available from 10X Genomics. There are 2,700 single cells that were sequenced on the Illumina NextSeq 500. The raw data can be found here.

We start by reading in the data. The [Read10X()](https://satijalab.org/seurat/reference/Read10X.html) function reads in the output of the cellranger pipeline from 10X, returning a unique molecular identified (UMI) count matrix. The values in this matrix represent the number of molecules for each feature (i.e. gene; row) that are detected in each cell (column).

We next use the count matrix to create a Seurat object. The object serves as a container that contains both data (like the count matrix) and analysis (like PCA, or clustering results) for a single-cell dataset. For a technical discussion of the Seurat object structure, check out our GitHub Wiki. For example, the count matrix is stored in pbmc[["RNA"]]@counts.

library(dplyr)
library(Seurat)
library(patchwork)

# Load the PBMC dataset
pbmc.data <- Read10X(data.dir = "../data/pbmc3k/filtered_gene_bc_matrices/hg19/")
# Initialize the Seurat object with the raw (non-normalized data).
pbmc <- CreateSeuratObject(counts = pbmc.data, project = "pbmc3k", min.cells = 3, min.features = 200)
pbmc

## An object of class Seurat 
## 13714 features across 2700 samples within 1 assay 
## Active assay: RNA (13714 features, 0 variable features)

<details open="" style="box-sizing: border-box; display: block;"><summary style="box-sizing: border-box; display: list-item;">What does data in a count matrix look like?</summary>

# Lets examine a few genes in the first thirty cells
pbmc.data[c("CD3D", "TCL1A", "MS4A1"), 1:30]

## 3 x 30 sparse Matrix of class "dgCMatrix"
##                                                                    
## CD3D  4 . 10 . . 1 2 3 1 . . 2 7 1 . . 1 3 . 2  3 . . . . . 3 4 1 5
## TCL1A . .  . . . . . . 1 . . . . . . . . . . .  . 1 . . . . . . . .
## MS4A1 . 6  . . . . . . 1 1 1 . . . . . . . . . 36 1 2 . . 2 . . . .

The . values in the matrix represent 0s (no molecules detected). Since most values in an scRNA-seq matrix are 0, Seurat uses a sparse-matrix representation whenever possible. This results in significant memory and speed savings for Drop-seq/inDrop/10x data.

dense.size <- object.size(as.matrix(pbmc.data))
dense.size

## 709591472 bytes

sparse.size <- object.size(pbmc.data)
sparse.size

## 29905192 bytes

dense.size/sparse.size

## 23.7 bytes
```</details> 

# [](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#standard-pre-processing-workflow)Standard pre-processing workflow

The steps below encompass the standard pre-processing workflow for scRNA-seq data in Seurat. These represent the selection and filtration of cells based on QC metrics, data normalization and scaling, and the detection of highly variable features.

## [](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#qc-and-selecting-cells-for-further-analysis)QC and selecting cells for further analysis

Seurat allows you to easily explore QC metrics and filter cells based on any user-defined criteria. A few QC metrics [commonly used](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4758103/) by the community include

*   The number of unique genes detected in each cell.
    *   Low-quality cells or empty droplets will often have very few genes
    *   Cell doublets or multiplets may exhibit an aberrantly high gene count
*   Similarly, the total number of molecules detected within a cell (correlates strongly with unique genes)
*   The percentage of reads that map to the mitochondrial genome
    *   Low-quality / dying cells often exhibit extensive mitochondrial contamination
    *   We calculate mitochondrial QC metrics with the `[PercentageFeatureSet()](https://satijalab.org/seurat/reference/PercentageFeatureSet.html)` function, which calculates the percentage of counts originating from a set of features
    *   We use the set of all genes starting with `MT-` as a set of mitochondrial genes

The [[ operator can add columns to object metadata. This is a great place to stash QC stats

pbmc[["percent.mt"]] <- PercentageFeatureSet(pbmc, pattern = "^MT-")

<details style="box-sizing: border-box; display: block;"><summary style="box-sizing: border-box; display: list-item;">**Where are QC metrics stored in Seurat?**</summary></details>

In the example below, we visualize QC metrics, and use these to filter cells.

*   We filter cells that have unique feature counts over 2,500 or less than 200
*   We filter cells that have >5% mitochondrial counts

Visualize QC metrics as a violin plot

VlnPlot(pbmc, features = c("nFeature_RNA", "nCount_RNA", "percent.mt"), ncol = 3)

[图片上传中...(image-434295-1634733928347-1)]

FeatureScatter is typically used to visualize feature-feature relationships, but can be used

for anything calculated by the object, i.e. columns in object metadata, PC scores etc.

plot1 <- FeatureScatter(pbmc, feature1 = "nCount_RNA", feature2 = "percent.mt")
plot2 <- FeatureScatter(pbmc, feature1 = "nCount_RNA", feature2 = "nFeature_RNA")
plot1 + plot2

[图片上传中...(image-b6ddc4-1634733928347-0)]

pbmc <- subset(pbmc, subset = nFeature_RNA > 200 & nFeature_RNA < 2500 & percent.mt < 5)

* * *

# [](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#normalizing-the-data)Normalizing the data

After removing unwanted cells from the dataset, the next step is to normalize the data. By default, we employ a global-scaling normalization method “LogNormalize” that normalizes the feature expression measurements for each cell by the total expression, multiplies this by a scale factor (10,000 by default), and log-transforms the result. Normalized values are stored in `pbmc[["RNA"]]@data`.

pbmc <- NormalizeData(pbmc, normalization.method = "LogNormalize", scale.factor = 10000)

For clarity, in this previous line of code (and in future commands), we provide the default values for certain parameters in the function call. However, this isn’t required and the same behavior can be achieved with:

pbmc <- NormalizeData(pbmc)

# [](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#identification-of-highly-variable-features-feature-selection)Identification of highly variable features (feature selection)

We next calculate a subset of features that exhibit high cell-to-cell variation in the dataset (i.e, they are highly expressed in some cells, and lowly expressed in others). We and [others](https://www.nature.com/articles/nmeth.2645) have found that focusing on these genes in downstream analysis helps to highlight biological signal in single-cell datasets.

Our procedure in Seurat is described in detail [here](https://doi.org/10.1016/j.cell.2019.05.031), and improves on previous versions by directly modeling the mean-variance relationship inherent in single-cell data, and is implemented in the `[FindVariableFeatures()](https://satijalab.org/seurat/reference/FindVariableFeatures.html)` function. By default, we return 2,000 features per dataset. These will be used in downstream analysis, like PCA.

pbmc <- FindVariableFeatures(pbmc, selection.method = "vst", nfeatures = 2000)

Identify the 10 most highly variable genes

top10 <- head(VariableFeatures(pbmc), 10)

plot variable features with and without labels

plot1 <- VariableFeaturePlot(pbmc)
plot2 <- LabelPoints(plot = plot1, points = top10, repel = TRUE)
plot1 + plot2

[图片上传中...(image-78ffdf-1634733928348-14)]

* * *

# [](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#scaling-the-data)Scaling the data

Next, we apply a linear transformation (‘scaling’) that is a standard pre-processing step prior to dimensional reduction techniques like PCA. The `[ScaleData()](https://satijalab.org/seurat/reference/ScaleData.html)` function:

*   Shifts the expression of each gene, so that the mean expression across cells is 0
*   Scales the expression of each gene, so that the variance across cells is 1
    *   This step gives equal weight in downstream analyses, so that highly-expressed genes do not dominate
*   The results of this are stored in `pbmc[["RNA"]]@scale.data`

all.genes <- rownames(pbmc)
pbmc <- ScaleData(pbmc, features = all.genes)

<details style="box-sizing: border-box; display: block;"><summary style="box-sizing: border-box; display: list-item;">**This step takes too long! Can I make it faster?**</summary></details> <details style="box-sizing: border-box; display: block;"><summary style="box-sizing: border-box; display: list-item;">**How can I remove unwanted sources of variation, as in Seurat v2?**</summary></details>

* * *

# [](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#perform-linear-dimensional-reduction)Perform linear dimensional reduction

Next we perform PCA on the scaled data. By default, only the previously determined variable features are used as input, but can be defined using `features` argument if you wish to choose a different subset.

pbmc <- RunPCA(pbmc, features = VariableFeatures(object = pbmc))

Seurat provides several useful ways of visualizing both cells and features that define the PCA, including `VizDimReduction()`, `[DimPlot()](https://satijalab.org/seurat/reference/DimPlot.html)`, and `[DimHeatmap()](https://satijalab.org/seurat/reference/DimHeatmap.html)`

Examine and visualize PCA results a few different ways

print(pbmc[["pca"]], dims = 1:5, nfeatures = 5)

PC_ 1

Positive: CST3, TYROBP, LST1, AIF1, FTL

Negative: MALAT1, LTB, IL32, IL7R, CD2

PC_ 2

Positive: CD79A, MS4A1, TCL1A, HLA-DQA1, HLA-DQB1

Negative: NKG7, PRF1, CST7, GZMB, GZMA

PC_ 3

Positive: HLA-DQA1, CD79A, CD79B, HLA-DQB1, HLA-DPB1

Negative: PPBP, PF4, SDPR, SPARC, GNG11

PC_ 4

Positive: HLA-DQA1, CD79B, CD79A, MS4A1, HLA-DQB1

Negative: VIM, IL7R, S100A6, IL32, S100A8

PC_ 5

Positive: GZMB, NKG7, S100A8, FGFBP2, GNLY

Negative: LTB, IL7R, CKB, VIM, MS4A7

VizDimLoadings(pbmc, dims = 1:2, reduction = "pca")

[图片上传中...(image-55b116-1634733928348-13)]

DimPlot(pbmc, reduction = "pca")

[图片上传中...(image-f0d6c8-1634733928348-12)]

In particular `[DimHeatmap()](https://satijalab.org/seurat/reference/DimHeatmap.html)` allows for easy exploration of the primary sources of heterogeneity in a dataset, and can be useful when trying to decide which PCs to include for further downstream analyses. Both cells and features are ordered according to their PCA scores. Setting `cells` to a number plots the ‘extreme’ cells on both ends of the spectrum, which dramatically speeds plotting for large datasets. Though clearly a supervised analysis, we find this to be a valuable tool for exploring correlated feature sets.

DimHeatmap(pbmc, dims = 1, cells = 500, balanced = TRUE)

[图片上传中...(image-f24a66-1634733928348-11)]

DimHeatmap(pbmc, dims = 1:15, cells = 500, balanced = TRUE)

[图片上传中...(image-45edc-1634733928348-10)]

# [](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#determine-the-dimensionality-of-the-dataset)Determine the ‘dimensionality’ of the dataset

To overcome the extensive technical noise in any single feature for scRNA-seq data, Seurat clusters cells based on their PCA scores, with each PC essentially representing a ‘metafeature’ that combines information across a correlated feature set. The top principal components therefore represent a robust compression of the dataset. However, how many components should we choose to include? 10? 20? 100?

In [Macosko *et al*](http://www.cell.com/abstract/S0092-8674(15)00549-8), we implemented a resampling test inspired by the JackStraw procedure. We randomly permute a subset of the data (1% by default) and rerun PCA, constructing a ‘null distribution’ of feature scores, and repeat this procedure. We identify ‘significant’ PCs as those who have a strong enrichment of low p-value features.

NOTE: This process can take a long time for big datasets, comment out for expediency. More

approximate techniques such as those implemented in ElbowPlot() can be used to reduce

computation time

pbmc <- JackStraw(pbmc, num.replicate = 100)
pbmc <- ScoreJackStraw(pbmc, dims = 1:20)

The `[JackStrawPlot()](https://satijalab.org/seurat/reference/JackStrawPlot.html)` function provides a visualization tool for comparing the distribution of p-values for each PC with a uniform distribution (dashed line). ‘Significant’ PCs will show a strong enrichment of features with low p-values (solid curve above the dashed line). In this case it appears that there is a sharp drop-off in significance after the first 10-12 PCs.

JackStrawPlot(pbmc, dims = 1:15)

[图片上传中...(image-f156f5-1634733928348-9)]

An alternative heuristic method generates an ‘Elbow plot’: a ranking of principle components based on the percentage of variance explained by each one (`[ElbowPlot()](https://satijalab.org/seurat/reference/ElbowPlot.html)` function). In this example, we can observe an ‘elbow’ around PC9-10, suggesting that the majority of true signal is captured in the first 10 PCs.

ElbowPlot(pbmc)

[图片上传中...(image-9b0e15-1634733928348-8)]

Identifying the true dimensionality of a dataset – can be challenging/uncertain for the user. We therefore suggest these three approaches to consider. The first is more supervised, exploring PCs to determine relevant sources of heterogeneity, and could be used in conjunction with GSEA for example. The second implements a statistical test based on a random null model, but is time-consuming for large datasets, and may not return a clear PC cutoff. The third is a heuristic that is commonly used, and can be calculated instantly. In this example, all three approaches yielded similar results, but we might have been justified in choosing anything between PC 7-12 as a cutoff.

We chose 10 here, but encourage users to consider the following:

*   Dendritic cell and NK aficionados may recognize that genes strongly associated with PCs 12 and 13 define rare immune subsets (i.e. MZB1 is a marker for plasmacytoid DCs). However, these groups are so rare, they are difficult to distinguish from background noise for a dataset of this size without prior knowledge.
*   We encourage users to repeat downstream analyses with a different number of PCs (10, 15, or even 50!). As you will observe, the results often do not differ dramatically.
*   We advise users to err on the higher side when choosing this parameter. For example, performing downstream analyses with only 5 PCs does significantly and adversely affect results.

* * *

# [](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#cluster-the-cells)Cluster the cells

Seurat v3 applies a graph-based clustering approach, building upon initial strategies in ([Macosko *et al*](http://www.cell.com/abstract/S0092-8674(15)00549-8)). Importantly, the *distance metric* which drives the clustering analysis (based on previously identified PCs) remains the same. However, our approach to partitioning the cellular distance matrix into clusters has dramatically improved. Our approach was heavily inspired by recent manuscripts which applied graph-based clustering approaches to scRNA-seq data [[SNN-Cliq, Xu and Su, Bioinformatics, 2015]](http://bioinformatics.oxfordjournals.org/content/early/2015/02/10/bioinformatics.btv088.abstract) and CyTOF data [[PhenoGraph, Levine *et al*., Cell, 2015]](http://www.ncbi.nlm.nih.gov/pubmed/26095251). Briefly, these methods embed cells in a graph structure - for example a K-nearest neighbor (KNN) graph, with edges drawn between cells with similar feature expression patterns, and then attempt to partition this graph into highly interconnected ‘quasi-cliques’ or ‘communities’.

As in PhenoGraph, we first construct a KNN graph based on the euclidean distance in PCA space, and refine the edge weights between any two cells based on the shared overlap in their local neighborhoods (Jaccard similarity). This step is performed using the `[FindNeighbors()](https://satijalab.org/seurat/reference/FindNeighbors.html)` function, and takes as input the previously defined dimensionality of the dataset (first 10 PCs).

To cluster the cells, we next apply modularity optimization techniques such as the Louvain algorithm (default) or SLM [[SLM, Blondel *et al*., Journal of Statistical Mechanics]](http://dx.doi.org/10.1088/1742-5468/2008/10/P10008), to iteratively group cells together, with the goal of optimizing the standard modularity function. The `[FindClusters()](https://satijalab.org/seurat/reference/FindClusters.html)` function implements this procedure, and contains a resolution parameter that sets the ‘granularity’ of the downstream clustering, with increased values leading to a greater number of clusters. We find that setting this parameter between 0.4-1.2 typically returns good results for single-cell datasets of around 3K cells. Optimal resolution often increases for larger datasets. The clusters can be found using the `[Idents()](https://satijalab.org/seurat/reference/Idents.html)` function.

pbmc <- FindNeighbors(pbmc, dims = 1:10)
pbmc <- FindClusters(pbmc, resolution = 0.5)

Modularity Optimizer version 1.3.0 by Ludo Waltman and Nees Jan van Eck

Number of nodes: 2638

Number of edges: 95965

Running Louvain algorithm...

Maximum modularity in 10 random starts: 0.8723

Number of communities: 9

Elapsed time: 0 seconds

Look at cluster IDs of the first 5 cells

head(Idents(pbmc), 5)

AAACATACAACCAC-1 AAACATTGAGCTAC-1 AAACATTGATCAGC-1 AAACCGTGCTTCCG-1

2 3 2 1

AAACCGTGTATGCG-1

6

Levels: 0 1 2 3 4 5 6 7 8

* * *

# [](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#run-non-linear-dimensional-reduction-umaptsne)Run non-linear dimensional reduction (UMAP/tSNE)

Seurat offers several non-linear dimensional reduction techniques, such as tSNE and UMAP, to visualize and explore these datasets. The goal of these algorithms is to learn the underlying manifold of the data in order to place similar cells together in low-dimensional space. Cells within the graph-based clusters determined above should co-localize on these dimension reduction plots. As input to the UMAP and tSNE, we suggest using the same PCs as input to the clustering analysis.

If you haven't installed UMAP, you can do so via reticulate::py_install(packages =

'umap-learn')

pbmc <- RunUMAP(pbmc, dims = 1:10)

note that you can set label = TRUE or use the LabelClusters function to help label

individual clusters

DimPlot(pbmc, reduction = "umap")

[图片上传中...(image-f67669-1634733928348-7)]

You can save the object at this point so that it can easily be loaded back in without having to rerun the computationally intensive steps performed above, or easily shared with collaborators.

saveRDS(pbmc, file = "../output/pbmc_tutorial.rds")

* * *

# [](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#finding-differentially-expressed-features-cluster-biomarkers)Finding differentially expressed features (cluster biomarkers)

Seurat can help you find markers that define clusters via differential expression. By default, it identifies positive and negative markers of a single cluster (specified in `ident.1`), compared to all other cells. `[FindAllMarkers()](https://satijalab.org/seurat/reference/FindAllMarkers.html)` automates this process for all clusters, but you can also test groups of clusters vs. each other, or against all cells.

The `min.pct` argument requires a feature to be detected at a minimum percentage in either of the two groups of cells, and the thresh.test argument requires a feature to be differentially expressed (on average) by some amount between the two groups. You can set both of these to 0, but with a dramatic increase in time - since this will test a large number of features that are unlikely to be highly discriminatory. As another option to speed up these computations, `max.cells.per.ident` can be set. This will downsample each identity class to have no more cells than whatever this is set to. While there is generally going to be a loss in power, the speed increases can be significant and the most highly differentially expressed features will likely still rise to the top.

find all markers of cluster 2

cluster2.markers <- FindMarkers(pbmc, ident.1 = 2, min.pct = 0.25)
head(cluster2.markers, n = 5)

p_val avg_log2FC pct.1 pct.2 p_val_adj

IL32 2.593535e-91 1.2154360 0.949 0.466 3.556774e-87

LTB 7.994465e-87 1.2828597 0.981 0.644 1.096361e-82

CD3D 3.922451e-70 0.9359210 0.922 0.433 5.379250e-66

IL7R 1.130870e-66 1.1776027 0.748 0.327 1.550876e-62

LDHB 4.082189e-65 0.8837324 0.953 0.614 5.598314e-61

find all markers distinguishing cluster 5 from clusters 0 and 3

cluster5.markers <- FindMarkers(pbmc, ident.1 = 5, ident.2 = c(0, 3), min.pct = 0.25)
head(cluster5.markers, n = 5)

p_val avg_log2FC pct.1 pct.2 p_val_adj

FCGR3A 2.150929e-209 4.267579 0.975 0.039 2.949784e-205

IFITM3 6.103366e-199 3.877105 0.975 0.048 8.370156e-195

CFD 8.891428e-198 3.411039 0.938 0.037 1.219370e-193

CD68 2.374425e-194 3.014535 0.926 0.035 3.256286e-190

RP11-290F20.3 9.308287e-191 2.722684 0.840 0.016 1.276538e-186

find markers for every cluster compared to all remaining cells, report only the positive

ones

pbmc.markers <- FindAllMarkers(pbmc, only.pos = TRUE, min.pct = 0.25, logfc.threshold = 0.25)
pbmc.markers %>%
group_by(cluster) %>%
slice_max(n = 2, order_by = avg_log2FC)

# A tibble: 18 × 7

# Groups: cluster [9]

p_val avg_log2FC pct.1 pct.2 p_val_adj cluster gene

<dbl> <dbl> <dbl> <dbl> <dbl> <fct> <chr>

1 1.17e- 83 1.33 0.435 0.108 1.60e- 79 0 CCR7

2 1.74e-109 1.07 0.897 0.593 2.39e-105 0 LDHB

3 0 5.57 0.996 0.215 0 1 S100A9

4 0 5.48 0.975 0.121 0 1 S100A8

5 7.99e- 87 1.28 0.981 0.644 1.10e- 82 2 LTB

6 2.61e- 59 1.24 0.424 0.111 3.58e- 55 2 AQP3

7 0 4.31 0.936 0.041 0 3 CD79A

8 9.48e-271 3.59 0.622 0.022 1.30e-266 3 TCL1A

9 4.93e-169 3.01 0.595 0.056 6.76e-165 4 GZMK

10 1.17e-178 2.97 0.957 0.241 1.60e-174 4 CCL5

11 3.51e-184 3.31 0.975 0.134 4.82e-180 5 FCGR3A

12 2.03e-125 3.09 1 0.315 2.78e-121 5 LST1

13 6.82e-175 4.92 0.958 0.135 9.36e-171 6 GNLY

14 1.05e-265 4.89 0.986 0.071 1.44e-261 6 GZMB

15 1.48e-220 3.87 0.812 0.011 2.03e-216 7 FCER1A

16 1.67e- 21 2.87 1 0.513 2.28e- 17 7 HLA-DPB1

17 3.68e-110 8.58 1 0.024 5.05e-106 8 PPBP

18 7.73e-200 7.24 1 0.01 1.06e-195 8 PF4

Seurat has several tests for differential expression which can be set with the test.use parameter (see our [DE vignette](https://satijalab.org/seurat/articles/de_vignette.html) for details). For example, the ROC test returns the ‘classification power’ for any individual marker (ranging from 0 - random, to 1 - perfect).

cluster0.markers <- FindMarkers(pbmc, ident.1 = 0, logfc.threshold = 0.25, test.use = "roc", only.pos = TRUE)

We include several tools for visualizing marker expression. `[VlnPlot()](https://satijalab.org/seurat/reference/VlnPlot.html)` (shows expression probability distributions across clusters), and `[FeaturePlot()](https://satijalab.org/seurat/reference/FeaturePlot.html)` (visualizes feature expression on a tSNE or PCA plot) are our most commonly used visualizations. We also suggest exploring `[RidgePlot()](https://satijalab.org/seurat/reference/RidgePlot.html)`, `[CellScatter()](https://satijalab.org/seurat/reference/CellScatter.html)`, and `[DotPlot()](https://satijalab.org/seurat/reference/DotPlot.html)` as additional methods to view your dataset.

VlnPlot(pbmc, features = c("MS4A1", "CD79A"))

[图片上传中...(image-bbefd3-1634733928347-6)]

you can plot raw counts as well

VlnPlot(pbmc, features = c("NKG7", "PF4"), slot = "counts", log = TRUE)

[图片上传中...(image-b12b78-1634733928347-5)]

FeaturePlot(pbmc, features = c("MS4A1", "GNLY", "CD3E", "CD14", "FCER1A", "FCGR3A", "LYZ", "PPBP",
"CD8A"))

[图片上传中...(image-f5b7b7-1634733928347-4)]

`[DoHeatmap()](https://satijalab.org/seurat/reference/DoHeatmap.html)` generates an expression heatmap for given cells and features. In this case, we are plotting the top 20 markers (or all markers if less than 20) for each cluster.

pbmc.markers %>%
group_by(cluster) %>%
top_n(n = 10, wt = avg_log2FC) -> top10
DoHeatmap(pbmc, features = top10$gene) + NoLegend()

[图片上传中...(image-38d138-1634733928347-3)]

* * *

# [](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#assigning-cell-type-identity-to-clusters)Assigning cell type identity to clusters

Fortunately in the case of this dataset, we can use canonical markers to easily match the unbiased clustering to known cell types:

| Cluster ID | Markers | Cell Type |
| --- | --- | --- |
| 0 | IL7R, CCR7 | Naive CD4+ T |
| 1 | CD14, LYZ | CD14+ Mono |
| 2 | IL7R, S100A4 | Memory CD4+ |
| 3 | MS4A1 | B |
| 4 | CD8A | CD8+ T |
| 5 | FCGR3A, MS4A7 | FCGR3A+ Mono |
| 6 | GNLY, NKG7 | NK |
| 7 | FCER1A, CST3 | DC |
| 8 | PPBP | Platelet |

new.cluster.ids <- c("Naive CD4 T", "CD14+ Mono", "Memory CD4 T", "B", "CD8 T", "FCGR3A+ Mono",
"NK", "DC", "Platelet")
names(new.cluster.ids) <- levels(pbmc)
pbmc <- RenameIdents(pbmc, new.cluster.ids)
DimPlot(pbmc, reduction = "umap", label = TRUE, pt.size = 0.5) + NoLegend()

[图片上传中...(image-4ef793-1634733928347-2)]

saveRDS(pbmc, file = "../output/pbmc3k_final.rds")

<details style="box-sizing: border-box; display: block;"><summary style="box-sizing: border-box; display: list-item;">**Session Info**</summary></details>

<nav id="toc" data-toggle="toc" style="box-sizing: border-box; display: block;">

## Contents

*   [Setup the Seurat Object](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#setup-the-seurat-object-1)
*   [Standard pre-processing workflow](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#standard-pre-processing-workflow-1)
*   [Normalizing the data](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#normalizing-the-data-1)
*   [Identification of highly variable features (feature selection)](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#identification-of-highly-variable-features-feature-selection-)
*   [Scaling the data](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#scaling-the-data-1)
*   [Perform linear dimensional reduction](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#perform-linear-dimensional-reduction-1)
*   [Determine the ‘dimensionality’ of the dataset](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#determine-the-dimensionality-of-the-dataset-1)
*   [Cluster the cells](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#cluster-the-cells-1)
*   [Run non-linear dimensional reduction (UMAP/tSNE)](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#run-non-linear-dimensional-reduction-umap-tsne-)
*   [Finding differentially expressed features (cluster biomarkers)](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#finding-differentially-expressed-features-cluster-biomarkers-)
*   [Assigning cell type identity to clusters](https://satijalab.org/seurat/articles/pbmc3k_tutorial.html#assigning-cell-type-identity-to-clusters-1)

</nav>

<footer style="box-sizing: border-box; display: flex; margin-top: 45px; padding: 35px 0px 36px; border-top: 1px solid rgb(229, 229, 229); color: rgb(102, 102, 102); flex-shrink: 0; font-family: Lato, &quot;Helvetica Neue&quot;, Helvetica, Arial, sans-serif; font-size: 15px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">

Developed by Paul Hoffman, Satija Lab and Collaborators.

Site built with [pkgdown](https://pkgdown.r-lib.org/) 1.6.1.

</footer>