Deeptools软件包模块

Deeptools.ses？scaleFactor模块

class deeptools.SES_scaleFactor.Tester

基类：object

deeptools.SES_scaleFactor.estimateScaleFactor(bamFilesList, binLength, numberOfSamples, normalizationLength, avg_method='median', blackListFileName=None, numberOfProcessors=1, verbose=False, chrsToSkip=[], mappingStatsList=[])

将基因组细分成块，以便使用几个处理器进行并行分析。该代码处理工作器的创建，这些工作器计算不同地区的碎片计数(覆盖率)，然后收集和集成结果。

参数

BamFilesList列表

要规格化的bam文件列表

二进制长度集成

要计算读取的窗口大小，单位为BP。

样本数集成

要从基因组中采样的位置数。有关更多信息，请参见CountReadsPerBin类的文档

规格化长度集成

长度，以BP为单位，以标准化数据。对于值1，平均每个碱基对有1个读数

avg_method应力

定义如何汇总不同的值。选项有“Mean”和“Medium”。

ChrsToSkip列表

要从比例估计中排除的染色体的名称。通常包括chrX。

BlackListFileName应力

包含黑名单区域的Bed文件

MappingStatsList列表

每个文件的映射读取数列表

退货

迪克特

具有以下关键字的词典：：

‘SIZE_FACTIONS’‘SIZE_FRANCES_BASS_BUSING_Mean’‘SIZE_FRANCES_BASS_BUSING_MERIAL’‘Mean’‘Meanes’‘Reads_per_bin’‘STD’‘Sites_Sampled’

实例

>>> test = Tester()
>>> bin_length = 50
>>> num_samples = 4
>>> _dict = estimateScaleFactor([test.bamFile1, test.bamFile2], bin_length, num_samples,  1)
>>> _dict['size_factors']
array([1. , 0.5])
>>> _dict['size_factors_based_on_mean']
array([1. , 0.5])

deeptools.bamhandler模块

deeptools.bamHandler.countReadsInInterval(args)

deeptools.bamHandler.getMappingStats(bam, nThreads)

这用于CRAM文件，因为idxstats()和.map/.unmap没有意义

这要求PYSAM>0.13.0

deeptools.bamHandler.openBam(bamFile, returnStats=False, nThreads=1, minimalDecoding=True)

用于打开BAM/CRAM文件的包装。

Bam文件：字符串

A BAM/CRAM文件名

返回统计数据：布尔值

返回(FILE_HANDLE、nMappdReads、nUnmappdReads、statsDict)的元组。一些下游函数需要这些附加值，因为不能在CRAM文件(或idxstats())上使用FILE_Handle.map

N线程：整型

如果reReturStats为True，则为用于计算统计信息的线程数

最小解码：布尔值

对于CRAM文件，不要解码Read Name、Sequence、Qual或辅助标记字段(大多数函数都不使用这些字段)。

返回文件句柄或元组，如relookStats中所述

Deeptools.Correlation模块

class deeptools.correlation.Correlation(matrix_file, corr_method=None, labels=None, remove_outliers=False, skip_zeros=False, log1p=False)

基类：object

类使用具有样本数据的矩阵来计算相关性、绘制它们以及绘制散点图

compute_correlation()

计算矩阵中样本的Spearman或Pearson相关性

矩阵应该包含每列每个样本的值，这就是使用转置的原因。

>>> matrix = np.array([[1, 2, 3, np.nan],
...                    [1, 2, 3, 4],
...                    [6, 4, 3, 1]]).T
>>> np.savez_compressed("/tmp/test_matrix.npz", matrix=matrix, labels=['a', 'b', 'c'])

>>> c = Correlation("/tmp/test_matrix.npz", corr_method='pearson')

结果应该如R中所示

>>> c.compute_correlation().filled(np.nan)
array([[ 1.        ,  1.        , -0.98198051],
       [ 1.        ,  1.        , -0.98198051],
       [-0.98198051, -0.98198051,  1.        ]])
>>> c.corr_method = 'spearman'
>>> c.corr_matrix = None
>>> c.compute_correlation()
array([[ 1.,  1., -1.],
       [ 1.,  1., -1.],
       [-1., -1.,  1.]])

static get_outlier_indices(data, max_deviation=200)

该方法是基于中位数绝对偏差的。见Boris Iglewicz和David Hoaglin(1993)，《第16卷：如何检测和处理异常值》，《ASQC基本参考文献中的质量控制：统计技术》，Edward F.Mykytka，Ph.D.，编辑。

返回不带离群值的列表

最大偏差=200类似于选择大于200的z分数，只是它基于中位数和中位数绝对偏差，而不是平均值和标准偏差。

load_matrix(matrix_file)

加载使用NumPy savez方法保存的矩阵文件。需要两个键：‘Matrix’和‘Labels’。矩阵每行应包含一个样本

plot_correlation(plot_filename, plot_title='', vmax=None, vmin=None, colormap='jet', image_format=None, plot_numbers=False, plotWidth=11, plotHeight=9.5)

使用对称热图绘制相关性

plot_pca(plot_filename=None, PCs=[1, 2], plot_title='', image_format=None, log1p=False, plotWidth=5, plotHeight=10, cols=None, marks=None)

绘制矩阵的主成分分析

返回打印值的矩阵。

plot_scatter(plot_filename, plot_title='', image_format=None, log1p=False, xRange=None, yRange=None)

绘制矩阵的散点图，其中每行都是一个样本

plotly_correlation(corr_matrix, plot_filename, labels, plot_title='', vmax=None, vmin=None, plot_numbers=True, colormap='jet')

PLOT_RECORATION，但使用PLOTHY

plotly_pca(plotFile, Wt, pvar, PCs, eigenvalues, cols, plotTitle)

Plot_PCA的绘图版本，它调用它来执行实际的绘图

plotly_scatter(plot_filename, corr_matrix, plot_title='', minXVal=None, maxXVal=None, minYVal=None, maxYVal=None)

用曲线图制作矩阵的散点图

remove_outliers(verbose=True)

获取异常值 per column 使用中位数绝对偏差法

返回过滤后的矩阵

remove_rows_of_zeros()

save_corr_matrix(file_handle)

保存相关矩阵

deeptools.correlation_heatmap模块

deeptools.correlation_heatmap.plot_correlation(corr_matrix, labels, plotFileName, vmax=None, vmin=None, colormap='jet', image_format=None, plot_numbers=False, plot_title='')

deeptools.countreadsPerbin模块

class deeptools.countReadsPerBin.CountReadsPerBin(bamFilesList, binLength=50, numberOfSamples=None, numberOfProcessors=1, verbose=False, region=None, bedFile=None, extendReads=False, genomeChunkSize=None, blackListFileName=None, minMappingQuality=None, ignoreDuplicates=False, chrsToSkip=[], stepSize=None, center_read=False, samFlag_include=None, samFlag_exclude=None, zerosToNans=False, skipZeroOverZero=False, smoothLength=0, minFragmentLength=0, maxFragmentLength=0, out_file_for_raw_data=None, bed_and_bin=False, statsList=[], mappedList=[])

基类：object

使用多处理功能收集多个bam文件的覆盖范围

此函数从几个bam文件中收集读取计数(覆盖率)，并返回一个带有结果的Numy数组。这个类使用多处理来计算覆盖率。

参数

BamFilesList列表

包含已索引的bam文件名称的列表。例如。 ['file1.bam', 'file2.bam']

二进制长度集成

窗/箱的长度。该值被以下各项推翻 bedFile 如果存在的话。

样本数集成

样本总数。基因组被分成 numberOfSamples ，每个窗口/仓位长度等于 binLength 。该值被以下各项推翻 stepSize 如果存在该值，则通过 bedFile 在这种情况下，样本数和垃圾箱数在床文件中定义

处理器数量集成

要使用的处理器数量。默认值为4

罗嗦布尔尔

输出消息。默认：FALSE

区域应力

区域限制计算，格式为chrom：Start：End。

床铺文件夹文件句柄列表。

每个文件句柄对应于包含要计算其覆盖范围的区域的BED文件。此选项将覆盖 binLength ， numberOfSamples 和 stepSize 。

BlackListFileName应力

包含带有黑名单区域的Bed文件的字符串。

ExtendReads：Bool，int

是否应计算扩展读取长度的覆盖范围(即，两个配对覆盖的区域或预期单次读取覆盖的区域)。如果值为‘int’，则将其解释为片段长度，以扩展未配对的读取。对于Illumina读数，通常的值在300左右。该值可以使用峰值调用者MACS2来确定，或者可以通过在为测序准备文库时计算的片段长度来近似。如果变量的值为真且未给定值，则仅当库成对结束时，才会从库中采样片段大小。默认：FALSE

MinMappingQuality集成

不考虑小于给定值的映射质量的读数。默认：无

忽略重复项布尔尔

是否读取重复(相同的开始、结束位置。如果是成对结束，则不包括配对)。默认：FALSE

ChrToSkip：列表

列出不希望包含在覆盖率计算中的染色体的名称。这对于去除不需要的染色体(例如，‘随机’或‘Het’)很有用。

步长集成

计算覆盖范围的职位定义如下： range(start, end, stepSize) 。因此，步长为1将计算每个碱基对的覆盖率。如果步长等于binLength，则为连续的bin计算覆盖率。如果seepSize小于binLength，则垃圾箱将重叠。

center_read布尔尔

确定读取是否应相对于片段长度居中。

samFlag_include集成

仅提取那些具有SAM标志的读取。例如，要仅获取第一个配对的读取，可以使用samFlag 64。同样，samFlag_Include可用于仅选择反向链上映射的读取，或仅获得正确配对的读取。

samFlag_exclude集成

删除与SAM标志匹配的读取。例如，要获得映射到正向链的所有读取，应该使用samFlag_exlud16。这意味着排除映射到反向链的所有读出。

ZeroosToNans布尔尔

如果为True，则会将遇到的零值转换为NANS。默认为FALSE。

SkipZeroOver Zero布尔尔

如果为True，则跳过所有输入BAM文件没有覆盖范围的垃圾箱(仅适用于bamCompare)。

最小分段长度集成

如果大于0，则排除此大小以下的碎片。

最大帧长度集成

如果大于0，则排除此大小以上的碎片。

out_file_for_raw_data应力

用于保存计算的原始计数的文件名

统计数据列表列表

对于bamFilesList中的每个BAM文件，由OpenBam返回的关联的每条染色体的统计信息

映射列表列表

对于bamFilesList中的每个BAM文件，文件中的映射读取次数。

bed_and_bin布尔型

如果为True并且给出了一个bedFile值，则计算每个区域中给定大小的每个bin的覆盖率

基因组块大小集成

如果不是没有，则是用于多重处理的基因组的长度。

退货

Numy数组

每行对应于每个箱/床区域，并且每列对应于每个bamFile。

实例

测试数据包含200个基点的读数。

>>> test = Tester()

转置函数用于获得更美观的输出。第一行对应于bam文件1中每个bin的读取次数

>>> c = CountReadsPerBin([test.bamFile1, test.bamFile2], 50, 4)
>>> np.transpose(c.run())
array([[0., 0., 1., 1.],
       [0., 1., 1., 2.]])

count_reads_in_region(chrom, start, end, bed_regions_list=None)

统计大小为binLength的窗口或bin在间隔(开始、结束)内每一步大小位置处的每个bam文件的读取量。

步长控制存储箱之间的距离。例如，步长大小为20和存储箱大小为20将创建彼此相邻的存储箱。如果步长小于仓位大小，则仓位将重叠。

如果给出了bedRegions列表，则计算与每个区域重叠的读取次数。

参数

铬应力

铬名称

开始集成

起点坐标

结束集成

终点坐标

Bed_Regions_List：列表

与要处理的床区域相对应的形式(开始、结束)的元组列表。如果没有将床文件传递给对象构造函数，则此列表为空。

退货

Numy数组

结果是一个数字数组，每个bin为行，每个bam文件为列。

实例

初始化一些有用的值

>>> test = Tester()
>>> c = CountReadsPerBin([test.bamFile1, test.bamFile2], 25, 0, stepSize=50)

转置用于获得更好看的数字。第一行对应于第一个bamfile中每个bin的读取次数。

>>> _array, __ = c.count_reads_in_region(test.chrom, 0, 200)
>>> _array
array([[0., 0.],
       [0., 1.],
       [1., 1.],
       [1., 2.]])

getReadLength(read)

getSmoothRange(tileIndex, tileSize, smoothRange, maxPosition)

在给定平铺索引位置和平铺大小(长度)的情况下，返回更大范围内的新索引，称为平滑范围。该区域在tileIndex中居中，跨越两种大小以覆盖平滑范围。如果平滑范围小于零或大于最大位置：：，则会修剪该范围

---------------|==================|------------------
           tileStart
      |--------------------------------------|
      |    <--      smoothRange     -->      |
      |
tileStart - (smoothRange-tileSize)/2

测试横跨3块瓷砖的平滑范围。

实例

>>> c = CountReadsPerBin([], 1, 1, 1, 0)
>>> c.getSmoothRange(5, 1, 3, 10)
(4, 7)

测试开始时截断的平滑范围。

>>> c.getSmoothRange(0, 10, 30, 200)
(0, 2)

测试开始时截断的平滑范围。

>>> c.getSmoothRange(1, 10, 30, 4)
(0, 3)

测试结束时截断的平滑范围。

>>> c.getSmoothRange(5, 1, 3, 5)
(4, 5)

测试平滑范围，而不是平铺大小的倍数。

>>> c.getSmoothRange(5, 10, 24, 10)
(4, 6)

get_chunk_length(bamFilesHandles, genomeSize, chromSizes, chrLengths)

get_coverage_of_region(bamHandle, chrom, regions, fragmentFromRead_func=None)

返回一个Numy数组，该数组对应于与每个平铺重叠的读取次数。

>>> test = Tester()
>>> import pysam
>>> c = CountReadsPerBin([], stepSize=1, extendReads=300)

在这种情况下，读取长度为36。对于测试的位置，重叠阅读片段的数量为4个和5个。

>>> c.get_coverage_of_region(pysam.AlignmentFile(test.bamFile_PE), 'chr2',
... [(5000833, 5000834), (5000834, 5000835)])
array([4., 5.])

在下面的示例中，将成对读取扩展到片段长度100，第一对从5000000开始，第二对从5000064开始。每个配对被扩展到片段长度 independently 在位置500090-500100，一个长度为100的片段重叠，并且在位置5000101之后应该有零读。

>>> c.zerosToNans = True
>>> c.get_coverage_of_region(pysam.AlignmentFile(test.bamFile_PE), 'chr2',
... [(5000090, 5000100), (5000100, 5000110)])
array([ 1., nan])

在以下情况下，读取长度为50。读取不会延长。

>>> c.extendReads=False
>>> c.get_coverage_of_region(pysam.AlignmentFile(test.bamFile2), '3R', [(148, 150), (150, 152), (152, 154)])
array([1., 2., 2.])

get_fragment_from_read(read)

获取读取的开始和结束位置。如果给定，则按如下方式扩展读取：如果读取是成对结束的，则每个读取配对被扩展以匹配片段长度，否则，使用默认片段长度。如果读取被拆分(由雪茄串给出)，则返回读取的多个位置。当扩展读取时，将跳过雪茄信息。

参数

阅读：帕萨姆物件。

定义下列值(用于正向读取)：

     |--          -- read.tlen --              --|
     |-- read.alen --|
-----|===============>------------<==============|----
     |               |            |
read.reference_start
            read.reference_end  read.pnext

  and for reverse reads


     |--             -- read.tlen --           --|
                                 |-- read.alen --|
-----|===============>-----------<===============|----
     |                           |               |
  read.pnext           read.reference_start  read.reference_end

这是一幅双端阅读的素描

该函数使用成对的结束信息(如果可用)或在适当的方向上扩展读取(如果这是单端的)，返回片段开始和结束。

参数

读取：PYSAM读取对象

退货

元组列表

[(fragment start, fragment end)]

>>> test = Tester()
>>> c = CountReadsPerBin([], 1, 1, 200, extendReads=True)
>>> c.defaultFragmentLength=100
>>> c.get_fragment_from_read(test.getRead("paired-forward"))
[(5000000, 5000100)]
>>> c.get_fragment_from_read(test.getRead("paired-reverse"))
[(5000000, 5000100)]
>>> c.defaultFragmentLength = 200
>>> c.get_fragment_from_read(test.getRead("single-forward"))
[(5001491, 5001691)]
>>> c.get_fragment_from_read(test.getRead("single-reverse"))
[(5001536, 5001736)]
>>> c.defaultFragmentLength = 'read length'
>>> c.get_fragment_from_read(test.getRead("single-forward"))
[(5001491, 5001527)]
>>> c.defaultFragmentLength = 'read length'
>>> c.extendReads = False
>>> c.get_fragment_from_read(test.getRead("paired-forward"))
[(5000000, 5000036)]

阅读居中测试。

>>> c = CountReadsPerBin([], 1, 1, 200, extendReads=True, center_read=True)
>>> c.defaultFragmentLength = 100
>>> assert c.get_fragment_from_read(test.getRead("paired-forward")) == [(5000032, 5000068)]
>>> c.defaultFragmentLength = 200
>>> assert c.get_fragment_from_read(test.getRead("single-reverse")) == [(5001618, 5001654)]

static is_proper_pair(read, maxPairedFragmentLength)

检查读数是否是正确的配对，这意味着两个配偶面朝对方，在同一条染色体上，距离不远。不能总是信任正确配对的SAM标志。请注意，如果片段大小大于MaxPairedFragmentLength(通常为~2kb)，则将返回FALSE。：Return：Bool

>>> import pysam
>>> import os
>>> from deeptools.countReadsPerBin import CountReadsPerBin as cr
>>> root = os.path.dirname(os.path.abspath(__file__)) + "/test/test_data/"
>>> bam = pysam.AlignmentFile("{}/test_proper_pair_filtering.bam".format(root))
>>> iter = bam.fetch()
>>> read = next(iter)
>>> cr.is_proper_pair(read, 1000) # "keep" read
True
>>> cr.is_proper_pair(read, 200) # "keep" read, but maxPairedFragmentLength is too short
False
>>> read = next(iter)
>>> cr.is_proper_pair(read, 1000) # "improper pair"
False
>>> read = next(iter)
>>> cr.is_proper_pair(read, 1000) # "mismatch chr"
False
>>> read = next(iter)
>>> cr.is_proper_pair(read, 1000) # "same orientation1"
False
>>> read = next(iter)
>>> cr.is_proper_pair(read, 1000) # "same orientation2"
False
>>> read = next(iter)
>>> cr.is_proper_pair(read, 1000) # "rev first"
False
>>> read = next(iter)
>>> cr.is_proper_pair(read, 1000) # "rev first OK"
True
>>> read = next(iter)
>>> cr.is_proper_pair(read, 1000) # "for first"
False
>>> read = next(iter)
>>> cr.is_proper_pair(read, 1000) # "for first"
True

run(allArgs=None)

class deeptools.countReadsPerBin.Tester

基类：object

getRead(readType)

准备测试参数

deeptools.countReadsPerBin.countReadsInRegions_wrapper(args)

将参数传递给CountReadsInRegions_Worker。考虑到多处理模块的限制，这是必需的步骤。Args变量包含来自CountReadsPerBin对象的‘self’值作为第一个元素

deeptools.countReadsPerBin.estimateSizeFactors(m)

计算尺寸系数的方法与DESeq2相同。返回与之相反的结果，因为它随后与bamCoverage兼容。

M：麻木的ndarray

>>> m = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [0, 10, 0], [10, 5, 100]])
>>> sf = estimateSizeFactors(m)
>>> assert np.all(np.abs(sf - [1.305, 0.9932, 0.783]) < 1e-4)
>>> m = np.array([[0, 0], [0, 1], [1, 1], [1, 2]])
>>> sf = estimateSizeFactors(m)
>>> assert np.all(np.abs(sf - [1.1892, 0.8409]) < 1e-4)

deeptools.countReadsPerBin.remove_row_of_zeros(matrix)

deeptools.getfragmentandreadsize模块

deeptools.getFragmentAndReadSize.getFragmentLength_worker(chrom, start, end, bamFile, distanceBetweenBins)

查询给定区域上的读取，以了解读取之间的距离和读取长度

参数

铬应力

染色体名称

开始集成

区域起点

结束集成

区域终点

Bam文件应力

BAM文件名

垃圾箱之间的距离集成

要忽略的每个bin末尾的碱基数

退货

np.array

Np数组，其中第一列是片段长度，第二列是读取长度

deeptools.getFragmentAndReadSize.getFragmentLength_wrapper(args)

deeptools.getFragmentAndReadSize.get_read_and_fragment_length(bamFile, return_lengths=False, blackListFileName=None, binSize=50000, distanceBetweenBins=1000000, numberOfProcessors=None, verbose=False)

通过采样估计片段长度和读取长度

Bam文件应力

BAM文件名

RETURN_LENGTHS：布尔数OfProcessors：Int详细：布尔bin大小：Int距离BetweenBins：Int

D迪克特

两个词典的元组，一个用于片段长度，另一个用于片段长度

用于读取长度。词典汇总了平均值、中位数等值

deeptools.getratio模块

deeptools.getRatio.compute_ratio(value1, value2, args)

deeptools.getRatio.getRatio(tileCoverage, args)

MapReduce方法会为每个平铺调用此函数。主方法中的参数(ARG)是固定的。

>>> funcArgs= {'valueType': 'ratio', 'scaleFactors': (1,1), 'pseudocount': [1, 1]}
>>> getRatio([9, 19], funcArgs)
0.5
>>> getRatio([0, 0], funcArgs)
1.0
>>> getRatio([np.nan, np.nan], funcArgs)
nan
>>> getRatio([np.nan, 1.0], funcArgs)
nan
>>> funcArgs['valueType'] ='subtract'
>>> getRatio([20, 10], funcArgs)
10
>>> funcArgs['scaleFactors'] = (1, 0.5)
>>> getRatio([10, 20], funcArgs)
0.0

倒数比为a，b为：如果a/b>1，则为a/b，否则为-1*b/a>函数参数 ['valueType'] =‘倒数比率’>函数参数 ['scaleFactors'] =(1，1)>函数参数 ['pseudocount'] = [0, 0] >getRatio( [2, 1] ，uncArgs)2.0>getRatio( [1, 2] ，uncArgs)-2.0>getRatio( [1, 1] ，uncArgs)1.0

deeptools.getscoreperbigwigbin模块

class deeptools.getScorePerBigWigBin.Tester

基类：object

deeptools.getScorePerBigWigBin.countFragmentsInRegions_worker(chrom, start, end, bigWigFiles, stepSize, binLength, save_data, bedRegions=None)

返回每个Bigwig文件在时间间隔开始和结束的时间间隔内的平均分数，每个大人物文件的平均分数为“binLength”。因为这样做是为了获得不同位置的窗口位置的计数以进行采样，所以垃圾箱的间距是相等的 not adjacent 。

如果给出了bedRegions列表，则计算与每个区域重叠的读取次数。

使用两个样本测试数据集，覆盖200个BP。>测试=测试仪()

碎片覆盖。>np.transpose(countFragmentsInRegions_worker(test.chrom，0、200、 [test.bwFile1, test.bwFile2] ，50，25，FALSE) [0] )数组( [[1., 1., 2., 2.] ，

[1., 1., 1., 3.] ])

>>> np.transpose(countFragmentsInRegions_worker(test.chrom, 0, 200, [test.bwFile1, test.bwFile2], 200, 200, False)[0])
array([[1.5],
       [1.5]])

床位区域：>床位区域= [[test.chrom, [(45, 55)] ], [test.chrom, [(95, 105)] ], [test.chrom, [(145, 155)] ]]>np.transpose(countFragmentsInRegions_worker(test.chrom，0,200， [test.bwFile1, test.bwFile2] ，200,200，FALSE，...BedRegions=bedRegions) [0] )数组( [[1. , 1.5, 2. ] ，

[1. , 1. , 2. ] ])

deeptools.getScorePerBigWigBin.countReadsInRegions_wrapper(args)

deeptools.getScorePerBigWigBin.getChromSizes(bigwigFilesList)

使用pyBigWig从Bigwig文件中获取染色体大小

使用两个样本测试数据集，覆盖200个BP。>测试=测试仪()

染色体名称(S)和大小(S)。>断言getChromSizes( [test.bwFile1, test.bwFile2] )==( [('3R', 200)] ，set([]))

deeptools.getScorePerBigWigBin.getScorePerBin(bigWigFiles, binLength, numberOfProcessors=1, verbose=False, region=None, bedFile=None, blackListFileName=None, stepSize=None, chrsToSkip=[], out_file_for_raw_data=None, allArgs=None)

此函数返回一个矩阵，其中包含区域内碎片覆盖率的分数(中位数)。每行对应于一个采样区域。同样，每一列都对应一个Bigwig文件。

使用两个样本测试数据集，覆盖200个BP。>test=Tester()>np.transpose(getScorePerBin( [test.bwFile1, test.bwFile2] ，50，3))数组( [[1., 1., 2., 2.] ，

[1., 1., 1., 3.] ])

Deeptools.Heatmapper模块

deeptools.heatmapper.chopRegions(exonsInput, left=0, right=0)

外显子是(开始、结束)元组的列表。我们的目标是将它们切成单独的元组列表，以照顾或未缩放的区域。“左”和“右”表示要从正常入库过程中排除的给定大小的区域(未缩放区域)。

这将输出三个(开始、结束)元组列表：

LeftBins：5‘未缩放区域BodyBins：用于缩放右侧的Body Bins：3’未缩放区域

另外还有两个整数padLeft：左边的填充基数(由于不能满足“Left”)padRight：与上面一样，但在右边

deeptools.heatmapper.chopRegionsFromMiddle(exonsInput, left=0, right=0)

与上面的Regions()类似，但返回外显子中心点两侧的两个元组列表。

具体步骤如下：

1. 找出外显子集合的中心点(例如， [(0, 200), (300, 400), (800, 900)] 将以200为中心)

• 如果给定的外显子跨越中心点，则外显子分裂

2. 提取位于中心左侧列表末尾的给定数量的基数

• 如果外显子集合没有包含足够的碱基，则padLeft会相应增加

3. 与上面相同，但对于中间偏右的列表

4. 返回(#2，#3，左侧填充，右侧填充)的元组

deeptools.heatmapper.computeSilhouetteScore(d, idx, labels)

给定一个具有NaN对角线的平方距离矩阵，计算给定行的轮廓分数(IDX)。每一行都应该有一个关联的标签。

deeptools.heatmapper.compute_sub_matrix_wrapper(args)

class deeptools.heatmapper.heatmapper

基类：object

类来处理矩阵的读取和绘制。

static change_chrom_names(chrom)

将UCSC染色体名称更改为集合染色体名称，反之亦然。

computeMatrix(score_file_list, regions_file, parameters, blackListFileName=None, verbose=False, allArgs=None)

将每个区域(由区域(Bed/GFF)文件中的散列‘#’定义)的每箱分数的计算拆分为多个核心。

static compute_sub_matrix_worker(self, chrom, start, end, score_file_list, parameters, regions)

退货

Numy矩阵

每行包含每个给定区域的值的数值矩阵

static coverage_from_array(valuesArray, zones, binSize, avgType)

static coverage_from_big_wig(bigwig, chrom, zones, binSize, avgType, nansAsZeros=False, verbose=True)

使用pyBigWig查询由chrom和zones定义的区域。输出是一个数组，其中包含每个碱基对的Bigwig值。当调用COVERAGE_FROM_ARRAY时，将在后面的步骤中完成对存储箱的汇总。这种方法比直接从大人物那里查询垃圾桶更可靠，后者应该更高效。

默认情况下，任何区域，即使在Bigwig文件上没有找到匹配的染色体，也会产生结果。换句话说，没有跳过任何区域。

Zones：数组如下：zone0：区域开始前的区域，

区域1：5‘未缩放区域(如果存在)区域2：区域主体(不总是存在)区域3：3’未缩放区域(如果存在)区域4：从区域末端向下游的区域

每个区域都是一个包含起始、结束和条柱数量的元组

如果要合并多个矩阵，或者需要将一次ComputeMatrix运算的已排序床输出用于其他情况，则此功能非常有用

getTicks(idx)

这本质上是对getProfileTicks的包装，以适应每个列都有自己的记号这一事实。

get_individual_matrices(matrix)

在一个接一个地保存多个矩阵的情况下，该方法将它们分开。返回包含矩阵的列表

get_num_individual_matrix_cols()

返回每个矩阵应具有的列数。这样做是因为绘制的最终矩阵可以由一个接一个合并的较小矩阵组成。

static matrix_avg(matrix, avgType='mean')

matrix_from_dict(matrixDict, regionsDict, parameters)

static my_average(valuesArray, avgType='mean')

计算平均值、中位数等，但仅计算非NAN的那些值

read_matrix_file(matrix_file)

save_BED(file_handle)

save_matrix(file_name)

保存重建矩阵所需的数据格式为：包含用于创建矩阵的参数的标题，编码为：@Key：Value Key2：Value2等...该文件的其余部分具有相同的Bed文件的前5列：染色体名称、开始、结束、名称、分数和链，所有这些列都由制表符分隔。在第五列之后，用制表符分隔添加矩阵值。通过添加以散列(#)开头、后跟组名的行来分隔组。

该文件是gzip格式的。

save_matrix_values(file_name)

save_tabulated_values(file_handle, reference_point_label='TSS', start_label='TSS', end_label='TES', averagetype='mean')

使用给定的avg_type保存由ol计算的平均值

参数：

FILE_HANDLE：保存文件的文件名REFERENCE_POINT_LABEL：参考点标签的名称START_LABEL：星形标签的名称END_LABEL：结束标签的名称Averagetype：Average类型(例如Mean、Medium、Std)

deeptools.heatmapper.trimZones(zones, maxLength, binSize, padRight)

给定(开始、结束)元组列表的(可变长度)列表，修剪/移除和延伸超过最大长度(例如，染色体的结束)的元组

返回裁剪后的区域和填充

deeptools.heatmapper_实用程序模块

deeptools.heatmapper_utilities.getProfileTicks(hm, referencePointLabel, startLabel, endLabel, idx)

返回与热图对应的xtick的位置和标签

在DeepTools3中，各种参数可以是列表，在这种情况下，我们需要对事物进行索引(idx参数)

从matplotlib 3开始，热图中的刻度需要加上0.5。

从matplotlib 3.1开始，不再为所有刻度添加填充。参考点刻度将调整宽度/2或宽度作为间距，缩放的刻度的后半部分将移动1个条柱，因此刻度位于条柱的开头。

deeptools.heatmapper_utilities.plot_single(ax, ma, average_type, color, label, plot_type='lines')

使用指定的方法向给定轴中的绘图添加一条线

参数

斧头Matplotlib轴

Matplotlib轴

体量Numy数组

Numy数组此矩阵上的数据根据 average_type 争论。

average_type应力

字符串值为总和平均值中值最小最大标准

颜色应力

有效颜色：html颜色名称、十六进制(例如#002233)、rgb+阿尔法元组或列表或rgb元组或列表

标签应力

标签

PLOT_TYPE：字符串

图的类型。‘se’表示标准误差，‘std’表示标准偏差，‘Overlapsed_Lines’表示绘制矩阵的每一行，Fill表示绘制x轴和值之间的区域，或者任何其他字符串表示仅绘制平均值。

退货

斧头

Matplotlib轴

实例

>>> import matplotlib.pyplot as plt
>>> import os
>>> fig = plt.figure()
>>> ax = fig.add_subplot(111)
>>> matrix = np.array([[1,2,3],
...                    [4,5,6],
...                    [7,8,9]])
>>> ax = plot_single(ax, matrix -2, 'mean', color=[0.6, 0.8, 0.9], label='fill light blue', plot_type='fill')
>>> ax = plot_single(ax, matrix, 'mean', color='blue', label='red')
>>> ax = plot_single(ax, matrix + 5, 'mean', color='red', label='red', plot_type='std')
>>> ax = plot_single(ax, matrix + 10, 'mean', color='#cccccc', label='gray se', plot_type='se')
>>> ax = plot_single(ax, matrix + 20, 'mean', color=(0.9, 0.5, 0.9), label='violet', plot_type='std')
>>> ax = plot_single(ax, matrix + 30, 'mean', color=(0.9, 0.5, 0.9, 0.5), label='violet with alpha', plot_type='std')
>>> leg = ax.legend()
>>> plt.savefig("/tmp/test.pdf")
>>> plt.close()
>>> fig = plt.figure()
>>> os.remove("/tmp/test.pdf")

deeptools.heatmapper_utilities.plotly_single(ma, average_type, color, label, plot_type='line')

一个Plot_Single的情节版本。返回跟踪列表

deeptools.mapreduce模块

deeptools.mapReduce.blSubtract(t, chrom, chunk)

如果基因组区域与列入黑名单的区域重叠，则将该区域减去

返回列表列表

deeptools.mapReduce.getUserRegion(chrom_sizes, region_string, max_chunk_size=1000000.0)

验证用户给出的给定区域参数是否有效。REGION_STRING的格式为chrom：Start：End：tileSize，其中Start、End和tileSize为可选。

参数:

• chrom_sizes -- 染色体/支架大小词典。Key=染色体名称

• region_string -- 格式为chr：Start：End的字符串

• max_chunk_size -- 区块大小的上限

返回:

区域开始、区域结束、块大小的元组chrom_Size

#>>> data = getUserRegion({'chr2': 1000}, "chr1:10:10") #Traceback (most recent call last): # ... #NameError: Unknown chromosome: chr1 #Known chromosomes are: ['chr2']

If the region end is biger than the chromosome size, this value is used instead >>> getUserRegion({'chr2': 1000}, "chr2:10:1001") ([('chr2', 1000)], 10, 1000, 990)

Test chunk and regions size reduction to match tile size >>> getUserRegion({'chr2': 200000}, "chr2:10:123344:3") ([('chr2', 123344)], 9, 123345, 123336)

Test chromosome name mismatch >>> getUserRegion({'2': 200000}, "chr2:10:123344:3") ([('2', 123344)], 9, 123345, 123336) >>> getUserRegion({'chrM': 200000}, "MT:10:123344:3") ([('chrM', 123344)], 9, 123345, 123336)

deeptools.mapReduce.mapReduce(staticArgs, func, chromSize, genomeChunkLength=None, region=None, bedFile=None, blackListFileName=None, numberOfProcessors=4, verbose=False, includeLabels=False, keepExons=False, transcriptID='transcriptID', exonID='exonID', transcript_id_designator='transcript_id', self_=None)

将基因组分割成几个部分，然后使用指定数量的处理程序将其发送给工人。结果被收集并返回。

对于每个基因组区域，使用以下参数调用给定的‘Func’：

Chrom、Start、End、StaticArgs

这个 arg 是静态的， pickable 需要发送给员工的变量。

基因组块长度对应于基因组的一小部分，以BP为单位，发送给每个工人进行处理。

根据工艺类型的不同，可能会选择较大或较短的区域

参数:

• chromSize -- 包含染色体名称及其长度的二元组列表

• region -- 格式为chr：Start：End：tileSize(请参阅函数getUserRegion)

• staticArgs -- 发送到给定‘函数’的参数元组

• func -- 要调用的函数。使用以下参数(chrom、Start、End、staticArgs)调用该函数

• bedFile -- 是床文件，则要调用的函数的参数被扩展以包括床定义区域的列表。

• blackListFileName -- 要从所有计算中排除的区域列表。请注意，这具有genomeChunkLength分辨率...

• self -- 如果MapReduce要调用对象，则必须传递self变量。

• includeLabels -- 将组标签和记录标签传递给调用函数。这些参数被添加到静态参数(groupLabel和转录名称)中。

如果“cluddeLabels”为True，则返回(Results，Labels)的元组

deeptools.sumCoveragePerBin

class deeptools.sumCoveragePerBin.SumCoveragePerBin(bamFilesList, binLength=50, numberOfSamples=None, numberOfProcessors=1, verbose=False, region=None, bedFile=None, extendReads=False, genomeChunkSize=None, blackListFileName=None, minMappingQuality=None, ignoreDuplicates=False, chrsToSkip=[], stepSize=None, center_read=False, samFlag_include=None, samFlag_exclude=None, zerosToNans=False, skipZeroOverZero=False, smoothLength=0, minFragmentLength=0, maxFragmentLength=0, out_file_for_raw_data=None, bed_and_bin=False, statsList=[], mappedList=[])

基类：CountReadsPerBin

这是与plotFingerprint一起使用的CountReadsPerBin的扩展。在这里，我们需要对每个基地的覆盖率进行求和。

get_coverage_of_region(bamHandle, chrom, regions, fragmentFromRead_func=None)

返回一个Numy数组，该数组对应于与每个平铺重叠的读取次数。

>>> test = Tester()
>>> import pysam
>>> c = SumCoveragePerBin([], stepSize=1, extendReads=300)

在这种情况下，读取长度为36。对于测试的位置，重叠阅读片段的数量为4个和5个。请注意，由于存在长度为0的BAM文件输入列表，因此读取没有扩展！

>>> c.get_coverage_of_region(pysam.AlignmentFile(test.bamFile_PE), 'chr2',
... [(5000833, 5000834), (5000834, 5000835)])
array([4., 5.])

在以下情况下，读取长度为50。读取不会延长。

>>> c.extendReads=False
>>> c.get_coverage_of_region(pysam.AlignmentFile(test.bamFile2), '3R', [(148, 150), (150, 152), (152, 154)])
array([2., 4., 4.])

class deeptools.sumCoveragePerBin.Tester

基类：object

deeptools.utilities模块

deeptools.utilities.bam_blacklisted_reads(bam_handle, chroms_to_ignore, blackListFileName=None, numberOfProcessors=1)

deeptools.utilities.bam_blacklisted_worker(args)

deeptools.utilities.bam_total_reads(bam_handle, chroms_to_ignore, stats)

计算BAM文件中映射读取的总数，过滤chroms_to_Ignore列表中给出的染色体

deeptools.utilities.convertCmap(c, vmin=0, vmax=1)

deeptools.utilities.copyFileInMemory(filePath, suffix='')

将文件复制到特殊的/dev/shm设备，该设备会将文件移动到内存中。此过程加快了多处理器对此类文件的访问速度

deeptools.utilities.getCommonChrNames(bamFileHandles, verbose=True)

比较bam文件句柄列表的名称和长度。输入是pysam文件句柄的列表。

该函数返回一个包含共同染色体名称和共同染色体长度的二元组。

希望只有_RANDOM和CHRM不常见。

deeptools.utilities.getGC_content(tb, chrom, fragStart, fragEnd, fraction=True)

deeptools.utilities.getTLen(read, notAbs=False)

获取观察到的读取模板长度。对于成对端读取，这通常只是TLEN字段。对于SE读取，这是观察到的基因组覆盖率(不包括剪接)。

deeptools.utilities.getTempFileName(suffix='')

返回临时文件名。调用函数负责在完成后将其删除。

deeptools.utilities.gtfOptions(allArgs=None)

这是用来设置MapReduce的参数的几个地方

deeptools.utilities.mungeChromosome(chrom, chromList)

一种通用的染色体吞噬功能。通过添加/删除“chr”来屏蔽“chrom”，使其出现在chromList中

出错时，不会返回任何内容，但应事先使用公共染色体列表以避免这种可能性

deeptools.utilities.smartLabel(label)

给定一个文件名(可能带有路径)，返回不带路径和去掉文件扩展名的文件名。因此，像/Path/to/ome.Special al.file这样的文件应该返回一些特殊的内容，因为只有第一个扩展名(如果有)应该被去掉。

deeptools.utilities.smartLabels(labels)

deeptools.utilities.tbitToBamChrName(tbitNames, bamNames)

检查两位和bam文件中的染色体名称是否一致。如果它们不一致，则尝试修复。如果成功，则返回映射表。TbitNames和bamNames应为列表

deeptools.utilities.toBytes(s)

与toString类似，但对于需要使用python3中的字节的函数

deeptools.utilities.toString(s)

这照顾到了 Python 2/3的差异

deeptools.writebedgraph模块

class deeptools.writeBedGraph.WriteBedGraph(bamFilesList, binLength=50, numberOfSamples=None, numberOfProcessors=1, verbose=False, region=None, bedFile=None, extendReads=False, genomeChunkSize=None, blackListFileName=None, minMappingQuality=None, ignoreDuplicates=False, chrsToSkip=[], stepSize=None, center_read=False, samFlag_include=None, samFlag_exclude=None, zerosToNans=False, skipZeroOverZero=False, smoothLength=0, minFragmentLength=0, maxFragmentLength=0, out_file_for_raw_data=None, bed_and_bin=False, statsList=[], mappedList=[])

基类：CountReadsPerBin

阅读BAM文件、覆盖范围并编写床单或大头文件

扩展CountReadsPerBin对象，以便bam文件的覆盖范围一次写入多个床单文件。

床单文件随后被合并为一个文件，并在必要时转换为大号文件。

构造函数参数与CountReadsPerBin相同。但是，在调用 run 方法，则必须传递以下参数

实例

在一个名为‘3R’的染色体上，给出了覆盖200个读数的以下分布：

  0                              100                           200
  |------------------------------------------------------------|
A                                ===============
                                                ===============


B                 ===============               ===============
                                 ===============
                                                ===============

>>> import tempfile
>>> test_path = os.path.dirname(os.path.abspath(__file__)) + "/test/test_data/"

>>> outFile = tempfile.NamedTemporaryFile()
>>> bam_file = test_path +  "testA.bam"

在本例中，将使用一个简单的缩放函数。此函数获取在每个区域找到的覆盖率，并将其乘以比例因子。在本例中，比例因子为1.5

>>> function_to_call = scaleCoverage
>>> funcArgs = {'scaleFactor': 1.5}

将处理限制在3R染色体位置0和200之间的区域

>>> region = '3R:0:200'

设置为为长度为25个BP>bin_Long=25>Step_Size=25的连续面元计算覆盖范围

>>> num_sample_sites = 0 #overruled by step_size
>>> c = WriteBedGraph([bam_file], binLength=bin_length, region=region, stepSize=step_size)
>>> c.run(function_to_call, funcArgs, outFile.name)
>>> f = open(outFile.name, 'r')
>>> f.readlines()
['3R\t0\t100\t0\n', '3R\t100\t200\t1.5\n']
>>> f.close()
>>> outFile.close()

run(func_to_call, func_args, out_file_name, blackListFileName=None, format='bedgraph', smoothLength=0)

在给定bamfile、函数和函数参数的列表的情况下，该方法将基因组分区的床头图文件(或大头)文件写成给定大小的块，以及对应于给定功能并与块下的覆盖相关的每个块的值。

参数

func_to_call应力

要调用的函数名，用于将为每个位置的每个BAM文件计算的Coverage列表转换为单个值。一个例子是取两个bam文件的覆盖率的函数。

func_args迪克特

dict of arguments to pass to func. E.g. {'scaleFactor':1.0}

out_file_name应力

要保存结果数据的文件的名称。

平滑长度集成

平滑每个平铺的覆盖范围的距离，以BP为单位。

writeBedGraph_worker(chrom, start, end, func_to_call, func_args, bed_regions_list=None)

根据在bamFiles上找到的阅读覆盖率编写卧铺记录

调用给定的函数来使用函数Args计算所需的床层值

参数

铬应力

铬名称

开始集成

起点坐标

结束集成

终点坐标

func_to_call应力

要调用的函数名，用于将为每个位置的每个BAM文件计算的Coverage列表转换为单个值。一个例子是取两个bam文件的覆盖率的函数。

func_args迪克特

要传递到的参数字典 func 。

平滑长度集成

平滑每个平铺的覆盖范围的距离，以BP为单位。

Bed_Regions_List：列表

与要处理的床区域相对应的形式(chrom、Start、End)的元组列表。如果没有将床文件传递给对象构造函数，则此列表为空。

退货

一份名单 [chromosome, start, end, temporary file] ，其中临时文件包含所查询区域的床图结果。

实例

>>> test_path = os.path.dirname(os.path.abspath(__file__)) + "/test/test_data/"
>>> bamFile1 = test_path +  "testA.bam"
>>> bin_length = 50
>>> number_of_samples = 0 # overruled by step_size
>>> func_to_call = scaleCoverage
>>> funcArgs = {'scaleFactor': 1.0}

>>> c = WriteBedGraph([bamFile1], bin_length, number_of_samples, stepSize=50)
>>> tempFile = c.writeBedGraph_worker( '3R', 0, 200, func_to_call, funcArgs)
>>> f = open(tempFile[3], 'r')
>>> f.readlines()
['3R\t0\t100\t0\n', '3R\t100\t200\t1\n']
>>> f.close()
>>> os.remove(tempFile[3])

deeptools.writeBedGraph.bedGraphToBigWig(chromSizes, bedGraphFiles, bigWigPath)

获取床头图文件的排序列表，并使用pyBigWig将它们写入单个Bigwig文件。BedGraphFiles的顺序必须与chromSizes的顺序匹配！

deeptools.writeBedGraph.getGenomeChunkLength(bamHandles, tile_size, mappedList)

试图根据每个bam文件的读取密度和bam文件的数量来估计发送给工作人员的基因组长度。

区块长度应为tileSize的倍数

deeptools.writeBedGraph.ratio(tile_coverage, args)

TileCoverage应该是两个元素的列表

deeptools.writeBedGraph.scaleCoverage(tile_coverage, args)

TileCoverage应该是只有一个元素的列表

deeptools.writeBedGraph.writeBedGraph_wrapper(args)

将参数传递给WriteBedGraph_Worker。考虑到多处理模块的限制，这是必需的步骤。Args变量包含来自WriteBedGraph对象的‘self’值作为第一个元素

deeptools.writebedgraph_bam_和_bw模块

deeptools.writeBedGraph_bam_and_bw.getCoverageFromBigwig(bigwigHandle, chrom, start, end, tileSize, missingDataAsZero=False)

deeptools.writeBedGraph_bam_and_bw.writeBedGraph(bamOrBwFileList, outputFileName, fragmentLength, func, funcArgs, tileSize=25, region=None, blackListFileName=None, numberOfProcessors=1, format='bedgraph', extendPairedEnds=True, missingDataAsZero=False, skipZeroOverZero=False, smoothLength=0, fixedStep=False, verbose=False)

在给定bamfile、函数和函数参数的列表的情况下，该方法将基因组分区的床头图文件(或大头)文件写成给定大小的块，以及对应于给定功能并与块下的覆盖相关的每个块的值。

deeptools.writeBedGraph_bam_and_bw.writeBedGraph_worker(chrom, start, end, tileSize, defaultFragmentLength, bamOrBwFileList, func, funcArgs, extendPairedEnds=True, smoothLength=0, skipZeroOverZero=False, missingDataAsZero=False, fixedStep=False)

以多个bam文件为基础编写床单。

调用给定的函数来使用函数Args计算所需的床层值

平铺大小

deeptools.writeBedGraph_bam_and_bw.writeBedGraph_wrapper(args)

模块内容

deepTools Galaxy <http://deeptools.ie-freiburg.mpg.de> _.

code @ github <https://github.com/deeptools/deepTools/> _.