Catchitt

Catchitt is a collection of tools for predicting cell type-specific binding regions of transcription factors (TFs) based on binding motifs and chromatin accessibility assays. The initial implementation of this methodology has been one of the winning approaches of the ENCODE-DREAM challenge ([1]) and is described in a preprint (https://www.biorxiv.org/content/early/2017/12/06/230011 doi: 10.1101/230011) and a recent paper. The implementation in Catchitt has been streamlined and slightly simplified to make its application more straight-forward. Specifically, we reduced the set of chromatin accessibility features to the most important ones, we simplified the sampling strategy of initial negative examples in the training step, and we omitted quantile normalization of chromatin accessibility features.

Catchitt tools

Catchitt comprises five tools for the individual steps of the pipeline (see below). The tool "labels" computes labels for genomic regions from "conservative" (i.e., IDR-thresholded) and "relaxed" ChIP-seq peaks. The tool "access" computes chromatin accessibility features from DNase-seq or ATAC-seq data, either based on fold-enrichment tracks in Bigwig format (e.g., MACS output) or based on SAM/BAM files of mapped reads. The tool "motif" computes motif-based features from genomic sequence and PWMs in Jaspar or HOCOMOCO format, or motif models from Dimont, including Slim models. The tool "itrain" performs iterative training of a series of classifiers based on labels, chromatin accessibility features, and motif features. The tool "predict" predicts binding probabilities of genomic regions based on trained classifiers and feature files. The feature files may either be measured on the training cell type (e.g., other chromosomes, "within cell type" case) or on a different cell type.

Downloads

We provide Catchitt as a pre-compiled JAR file and also publish its source code under GPL 3. For compiling Catchitt from source files, Jstacs (v. 2.3 and later) and the corresponding external libraries are required.

Catchitt is distributed in the hope that it will be useful, but without any warranty; without even the implied warranty of merchantability or fitness for a particular purpose.

• JAR download
• the source code of Catchitt is available from github in package projects.encodedream.
• motifs used in the ENCODE-DREAM challenge

Citation

If you use Catchitt in your research, please cite

J. Keilwagen, S. Posch, and J. Grau. Accurate prediction of cell type-specific transcription factor binding. Genome Biology, 20(1):9, 2019.

Usage

Catchitt can be started by calling

java -jar Catchitt.jar

on the command line. This lists the names of the available tools with a short description:

Available tools:

	access - Chromatin accessibility
	methyl - Methylation levels
	motif - Motif scores
	labels - Derive labels
	itrain - Iterative Training
	predict - Prediction

Syntax: java -jar Catchitt.jar <toolname> [<parameter=value> ...]

Further info about the tools is given with
	java -jar Catchitt.jar <toolname> info

Tool parameters are listed with
	java -jar Catchitt.jar <toolname>

Tools

Derive labels

Derive labels computes labels for genomic regions based on ChIP-seq peak files. The input ChIP-seq peak files must be provided in narrowPeak format and may come in 'conservative', i.e., IDR-thresholded, and 'relaxed' flavors. In case only a single peak file is available, both of the corresponding parameters may be set to this one peak file. The parameter for the bin width defines the resolution of genomic regions that is assigned a label, while the parameter for the region width defines the size of the regions considered. If, for instance, the bin width is set to 50 and the region width to 100, regions of 100 bp shifted by 50 bp along the genome are labeled. The labels assigned may be 'S' (summit) is the current bin contains the annotated summit of a conservative peak, 'B' (bound) if the current region overlaps a conservative peak by at least half the region width, 'A' (ambiguous) if the current region overlaps a relaxed peak by at least 1 bp, or 'U' (unbound) if it overlaps with none of the peaks. The output is provided as a gzipped file 'Labels.tsv.gz' with columns chromosome, start position, and label. This output file together with a protocol of the tool run is saved to the specified output directory.

Derive labels may be called with

java -jar Catchitt.jar labels

and has the following parameters

name	comment	type
c	Conservative peaks (NarrowPeak file containing the conservative peaks)	FILE
r	Relaxed peaks (NarrowPeak file containing the relaxed peaks)	FILE
f	FAI of genome (FastA index file of the genome)	FILE
b	Bin width (The width of the genomic bins considered, valid range = [1, 10000], default = 50)	INT
rw	Region width (The width of the genomic regions considered for overlaps, valid range = [1, 10000], default = 50)	INT
outdir	The output directory, defaults to the current working directory (.)	STRING

Example:

java -jar Catchitt.jar labels c=conservative.narrowPeak r=relaxed.narrowPeak f=hg19.fa.fai b=50 rw=200 outdir=labels

Chromatin accessibility

Chromatin accessibility computes several chromatin accessibility features from DNase-seq or ATAC-seq data provided as fold-enrichment tracks or SAM/BAM files of mapped reads. Features a computed with a certain resolution defined by the bin width parameter. Setting this parameter to 50, for instance, features are computed for non-overlapping 50 bp bins along the genome. If input data are provided as SAM/BAM file, coverage information is extracted and normalized locally in a similar fashion as proposed for the MACS peak caller. Output is provided as a gzipped file 'Chromatin_accessibility.tsv.gz' with columns chromosome, start position of the bin, minimum coverage and median coverage in the current bin, minimum coverage in 1000 bp regions before and after the current bin, maximum coverage in 1000 bp regions before and after the current bin, the number of steps in the coverage profile, and the number of monotonically increasing and decreasing steps in the coverage profile of the current bin. This output file together with a protocol of the tool run is saved to the specified output directory.

Chromatin accessibility may be called with

java -jar Catchitt.jar access

and has the following parameters

name	comment	type
d	Data source (The format of the input file containing the coverage information, range={BAM/SAM, Bigwig}, default = BAM/SAM) Parameters for selection "BAM/SAM": i Input SAM/BAM (The input file containing the mapped DNase-seq/ATAC-seq reads) FILE Parameters for selection "Bigwig": i Input Bigwig (The input file containing the mapped DNase-seq/ATAC-seq reads) FILE f FastA index (The genome index) FILE
b	Bin width (The width of the genomic bins considered)	INT
outdir	The output directory, defaults to the current working directory (.)	STRING

Example:

java -jar Catchitt.jar access d="Bigwig" i=fold_enrich.bw f=hg19.fa.fai b=50 outdir=dnase

Motif scores

Motif scores computes features based on motif scores of a given motif model scanning sub-sequences along the genome. Motif scores are aggregated in bins of the specified width as maximum score and log of the average exponential score (i.e., average log-likelihood in case of statistical models). The motif model may be provided as PWMs in HOCOMOCO or PFMs in Jaspar format, or as Dimont motif models in XML format. For more complex motif models like Slim models, the current implementation uses several indexes to speed-up the scanning process. However, computation of these indexes is rather memory-consuming and often not reasonable for simple PWM models. Hence, a low-memory variant of the tool is available, which is typically only slightly slower for PWM models but substantially slower for Slim models. Output is provided as a gzipped file 'Motif_scores.tsv.gz' containing columns chromosome, start position, maximum and average score. This output file together with a protocol of the tool run is saved to the specified output directory.

Motif scores may be called with

java -jar Catchitt.jar motif

and has the following parameters

name	comment	type
m	Motif model (The motif model in Dimont, HOCOMOCO, or Jaspar format, range={Dimont, HOCOMOCO, Jaspar}, default = Dimont) Parameters for selection "Dimont": d Dimont motif (Dimont motif model description) FILE Parameters for selection "HOCOMOCO": h HOCOMOCO PWM (PWM from the HOCOMOCO database) FILE Parameters for selection "Jaspar": j Jaspar PFM (PFM in Jaspar format) FILE
g	Genome (Genome as FastA file)	FILE
f	FAI of genome (FastA index file of the genome)	FILE
b	Bin width (The width of the genomic bins considered)	INT
l	Low-memory mode (Use slower mode with a smaller memory footprint, default = true)	BOOLEAN
outdir	The output directory, defaults to the current working directory (.)	STRING
threads	The number of threads used for the tool, defaults to 1	STRING

Example

java -jar Catchitt.jar motif m=HOCOMOCO h=motif.pwm g=hg19.fa f=hg19.fa.fai b=50 outdir=motifs

Iterative Training

Iterative Training performs an iterative training with the specified number of iterations to obtain a series of classifiers that may be used for predictions in the same cell type or in other cell types based on a corresponding set of feature files. The tool requires as input labels for the training chromosomes, a chromatin accessibility feature file and a set of motif feature files. From the labels, an initial set of training regions is extracted containing all positive examples labeled as 'S' (summit) and a sub-sample of negative examples of regions labeled as 'U' (unbound). During the iterations, the initial negative examples are complemented with additional negatives obtaining large binding probabilities, i.e., putative false positive predictions. As these additional negative examples are derived from predictions of the current set of classifiers, the number of bins used for aggregation needs to be specified and should be identical to those used for predictions later. Training chromosomes and chromosomes used for predictions in the iterative training may be specified, as well as the percentile of the scores of positive (i.e., summit or bound regions) that should be used to identify putative false positives. The specified bin width must be identical to the bin width specified when computing the corresponding feature files. Feature vectors for training regions may span several adjacent bins as specified by the bin width parameter. Output is an XML file Classifiers.xml containing the set of trained classifiers. This output file together with a protocol of the tool run is saved to the specified output directory.

Iterative Training may be called with

java -jar Catchitt.jar itrain

and has the following parameters

name	comment	type
a	Accessibility (File containing accessibility features)	FILE
m	Motif (File containing motif features), MAY BE USED MULTIPLE TIMES	FILE
l	Labels (File containing the labels)	FILE
f	FAI of genome (FastA index file of the genome)	FILE
b	Bin width (The width of the genomic bins, valid range = [1, 1000], default = 50)	INT
n	Number of bins (The number of adjacent bins, valid range = [1, 20], default = 5)	INT
abb	Aggregation: bins before (The number of bins before the current one considered in the aggregation, valid range = [1, 20], default = 1)	INT
aba	Aggregation: bins after (The number of bins after the current one considered in the aggregation, valid range = [1, 20], default = 4)	INT
i	Iterations (The number of iterations of the interative training, valid range = [1, 20], default = 5)	INT
t	Training chromosomes (Training chromosomes, separated by commas, OPTIONAL)	STRING
itc	Iterative training chromosomes (Chromosomes with predictions in iterative training, separated by commas, OPTIONAL)	STRING
p	Percentile (Percentile of the prediction scores of positives used as threshold in iterative training, valid range = [0.0, 1.0], default = 0.01)	DOUBLE
outdir	The output directory, defaults to the current working directory (.)	STRING
threads	The number of threads used for the tool, defaults to 1	STRING

Example

java -jar Catchitt.jar itrain a=dnase/Chromatin_accessibility.tsv.gz m=motif1/Motif_scores.tsv.gz m=motif2/Motif_scores.tsv.gz l=labels/Labels.tsv.gz f=hg19.fa.fai b=50 n=5 abb=1 aba=4 i=5 t="chr1,chr2,chr3" itc="chr1,chr2" p=0.01 outdir=cls

Prediction

Prediction predicts binding probabilities of genomic regions as specified during training of the set of classifiers in iterative training. As input, Prediction requires a set of trained classifiers in XML format, the same (type of) feature files as used in training (motif files must be specified in the same order!). In addition, the chromosomes for which predictions are made may be specified, and the number of bins used for aggregation may be specified to deviate from those used during training. If these bin numbers are not specified, those from the training run are used. Finally, it is possible to restrict the number of classifiers considered to the first n ones. Output is provided as a gzipped file 'Predictions.tsv.gz' with columns chromosome, start position, binding probability. This output file together with a protocol of the tool run is saved to the specified output directory.

Prediction may be called with

java -jar Catchitt.jar predict

and has the following parameters

name	comment	type
c	Classifiers (The classifiers trained by iterative training)	FILE
a	Accessibility (File containing accessibility features)	FILE
m	Motif (File containing motif features) MAY BE USED MULTIPLE TIMES	FILE
f	FAI of genome (FastA index file of the genome)	FILE
p	Prediction chromosomes (Prediction chromosomes, separated by commas, OPTIONAL)	STRING
abb	Aggregation: bins before (Number of bins before the current one considered for aggregation., OPTIONAL)	INT
aba	Aggregation: bins after (Number of bins after the current one considered for aggregation., OPTIONAL)	INT
n	Number of classifiers (Use only the first k classifiers for predictions., OPTIONAL)	INT
outdir	The output directory, defaults to the current working directory (.)	STRING

Example

java -jar Catchitt.jar predict c=cls/Classifiers.xml a=dnase/Chromatin_accessibility.tsv.gz m=motif1/Motif_scores.tsv.gz m=motif2/Motif_scores.tsv.gz f=hg19.fa.fai p="chr8,chr21" abb=1 aba=4 n=3 outdir=predict

Standard pipeline

The standard Catchitt pipeline would comprise the following steps

• for a training cell type, collect ChIP-seq peak files (preferably conservative and relaxed peaks) in narrowPeak format and derive labels for genomic regions (Derive labels)
• for the same cell type, collect chromatin accessibility data (DNase-seq or ATAC-seq) as fold-enrichment tracks or mapping files, and derive chromatin accessibility features from those data (Chromatin accessibility)
• collect or learn (e.g., using Dimont a set of motif models for the transcription factor of interest, and scan the genome using these motif models (Motif scores)
• perform iterative training given the labels and feature files (Iterative Training)
• predict binding probabilities of genomic regions in the same cell type or in other cell types. In the latter case, additional chromatin accessibility data for these target cell types need to be collected and features need to be derived as in step 2. (Prediction)

Tutorial using ENCODE data

We describe a typical Catchitt pipeline using public ENCODE data for the transcription factor CTCF in two cell lines. This tutorial uses real-world data on the whole ENCODE GRCh38 human genome version, illustrating different DNase-seq input formats and different motif sources. Please note that this realistic scenario also comes at the expense of real-world runtimes of the individual Catchitt steps.

For best performance, we would further recommend

• to use multiple motifs from different sources, including motifs derived from DNase-seq (available in our motif collection of the ENCODE-DREAM challenge in directory de-novo/DNase-peaks
• to use replicate information for DNase data, for instance using the pipeline of the Kundaje lab

In this tutorial, we concentrate on the Catchitt pipeline and illustrate its usage based on readily available data.

Obtaining training and test data

First, we need the GRCh38 genome version used by ENCODE. This genome is available as a gzipped FastA file from ENCODE at

https://www.encodeproject.org/files/GRCh38_no_alt_analysis_set_GCA_000001405.15/@@download/GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta.gz

After download, the genome needs to be gunzipped and indexed using the samtools faidx command:

gunzip GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta.gz
samtools faidx GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta

In the following, we assume that genome FastA and index are in the base directory.

In addition, we need the DNase-seq data. We consider two cell lines ("astrocyte of the spinal cord" and "fibroblast of villous mesenchyme"). The corresponding DNase-seq data are available from ENCODE under accessions ENCSR000ENB and ENCSR000EOR, respectively. Here, we first consider the Bigwig files of the first replicate for each cell line, which can be downloaded from the following URLs:

https://www.encodeproject.org/files/ENCFF901UBX/@@download/ENCFF901UBX.bigWig
https://www.encodeproject.org/files/ENCFF652HJH/@@download/ENCFF652HJH.bigWig

For obtaining labels for CTCF binding, we further need ChIP-seq peaks. Here, we consider the ChIP-seq experiment with accession ENCSR000DSU for the astrocytes, which will become our training data in the following: The corresponding "conservative" and "relaxed" peak files for astrocytes are available from

https://www.encodeproject.org/files/ENCFF183YLB/@@download/ENCFF183YLB.bed.gz
https://www.encodeproject.org/files/ENCFF600CYD/@@download/ENCFF600CYD.bed.gz

Again, the peak files need to be gunzipped for the following steps.

Finally, we need a motif model for CTCF, which we download from HOCOMOCO in this case

http://hocomoco11.autosome.ru/final_bundle/hocomoco11/full/HUMAN/mono/pwm/CTCF_HUMAN.H11MO.0.A.pwm

We organize all these files (and the Catchitt JAR) in the following directory structure

.:
Catchitt.jar
GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta
GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta.fai

./astrocytes:
ENCFF183YLB.bed
ENCFF600CYD.bed
ENCFF901UBX.bigWig

./fibroblasts:
ENCFF652HJH.bigWig

./motifs/CTCF/:
CTCF_HUMAN.H11MO.0.A.pwm

Deriving labels

As we use supervised training of model parameters, we need labels for the genomic regions, qualifying these as bound (B) or unbound (U). Besides, we have additional labels for bound regions at the peak summit (S) and ambiguous regions (A) that are (partly) covered by relaxed but not by conservative peaks.

For training purposes, we need to derive labels from the astrocyte ChIP-seq peaks by calling

java -jar Catchitt.jar labels c=astrocytes/ENCFF183YLB.bed\
    r=astrocytes/ENCFF600CYD.bed\
    f=GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta.fai\
    b=50 rw=200 outdir=astrocytes/labels

Here, we use a bin width of 50 bp (i.e., we resolve any feature or binding event with 50 bp resolution) and a region width of 200 bp as used in ENCODE-DREAM. A detailed description of the partitioning of the genome into non-overlapping bins and the logic behind the regions for which prediction are made, may be found in the Catchitt paper. The result is a file astrocytes/labels/Labels.tsv.gz with the following format

chr1    0       U
chr1    50      U
chr1    100     U
chr1    150     U
chr1    200     U
chr1    250     U

where the columns contain chromosome, bin starting position, and corresponding label, and are separated by tabs.

Preparing DNase data from bigwig format

We further derive DNase-seq features from the bigwig file that we downloaded in the first step. Again, we specify a bin width of 50 bp.

java -jar Catchitt.jar access d="Bigwig" i=astrocytes/ENCFF901UBX.bigWig f=GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta.fai\
    b=50 outdir=astrocytes/access

The result is a file astrocytes/access/Chromatin_accessibility.tsv.gz with the following format

chr1    1033400 0.03954650089144707     0.05627769976854324     0.009126120246946812    0.030420400202274323    0.06692489981651306     1.03125 3.0     1.0     0.0
chr1    1033450 0.030420400202274323    0.03650449961423874     0.009126120246946812    0.030420400202274323    0.045630600303411484    1.03125 2.0     0.0     0.0
chr1    1033500 0.024336300790309906    0.03346240147948265     0.009126120246946812    0.030420400202274323    0.045630600303411484    1.03125 2.0     1.0     0.0
chr1    1033550 0.01825219951570034     0.024336300790309906    0.009126120246946812    0.024336300790309906    0.060840800404548645    1.03125 2.0     0.0     1.0

where the first two columns, again, correspond to chromosome and starting position, and the remaining columns are

• minimum DNase value in bin,
• median DNase value in bin,
• minimum in 1000 bp after bin start,
• minimum in 1000 bp before bin start,
• maximum in 1000 bp after bin start,
• maximum in 1000 bp before bin start,
• the number of steps in the bin profile,
• the length of the longest monotonically increasing range in the bin,
• the length of the longest monotonically decreasing range in the bin.

Preparing motif scores

We also compute motif scores along the genome for the PWM we downloaded from HOCOMOCO:

java -jar Catchitt.jar motif m="HOCOMOCO" h=motifs/CTCF/CTCF_HUMAN.H11MO.0.A.pwm g=GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta\
    f=GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta.fai b=50 outdir=motifs/CTCF threads=3

The result is a file motifs/CTCF/Motif_scores.tsv.gz with the following format

chr1    46950   -4.996643       -4.9543528358429105
chr1    47000   -5.984124       -5.451674735652041
chr1    47050   -0.8633305      -0.4596223585537509
chr1    47100   -4.9379983      -4.813470561120627

where the first two columns, again, correspond to chromosome and starting position, and the remaining two columns are

• the maximum motif score within the bin,
• the logarithm of the exponentials of the individual scores with the bin; for scores that are log-likelihoods, this is proportional to the log-likelihood of the complete sequence.

Iterative training

With all the feature files prepared, we may now run the iterative training procedure. Here, we use all main chromosomes for training, use five of those chromosomes also for generating new negative examples in each of the iterations, and use 8 computation threads for the numeric optimization of model parameters. At this stage, it is critical that all feature files have been generated from the same reference. This way, we may sweep in parallel over all feature files that, at each line, represent the identical genomic location. Otherwise, the iterative training will throw an error stating that the chromosomes do not match at a certain line of the input files.

We start iterative training by calling

java -jar Catchitt.jar itrain a=astrocytes/access/Chromatin_accessibility.tsv.gz m=motifs/CTCF/Motif_scores.tsv.gz\
    l=astrocytes/labels/Labels.tsv.gz f=GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta.fai\
    b=50 t='chr2,chr3,chr4,chr5,chr6,chr7,chr9,chr10,chr11,chr12,chr13,chr14,chr15,chr16,chr17,chr17,chr18,chr19,chr20,chr22'\
    itc='chr10,chr11,chr12,chr13,chr14' outdir=astrocytes/itrain threads=8

which results in a file astrocytes/itrain/Classifiers.xml containing the trained classifiers.

Predicting binding in new cell types

Using the trained classifier from the previous step and the DNase data for fibroblasts prepared before, we may now predict binding in the fibroblast cell type. In the example, we generate predictions only for chromosome 8, which could be extended to other chromosomes using parameter "p":

java -jar Catchitt.jar predict c=astrocytes/itrain/Classifiers.xml a=fibroblasts/access/Chromatin_accessibility.tsv.gz\
    m=motifs/CTCF/Motif_scores.tsv.gz f=GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta.fai\
    p="chr8" outdir=fibroblasts/predict

This finally results in a file fibroblasts/predict/Predictions.tsv.gz containing the predicted binding probabilities per region. This file has three columns, corresponding to chromosome, starting position, and binding probability:

chr8    265850  0.9866555574053496
chr8    265900  0.9865107771922306
chr8    265950  0.9864837006927715
chr8    266000  0.8041139249973046
chr8    266050  0.19870629729482686
chr8    266100  0.1302269536110939
chr8    266150  0.09693322015563202

Using DNase-seq BAM files and multiple motifs

Instead of bigwig files, the "access" tool of Catchitt also accepts BAM files of mapped DNase-seq (or ATAC-seq) data. Internally, this tool counts 5' ends of reads, and performs local normalization of read depth and average smoothing. Here, we download the BAM files corresponding to the previous bigwig files from ENCODE

https://www.encodeproject.org/files/ENCFF384CCQ/@@download/ENCFF384CCQ.bam
https://www.encodeproject.org/files/ENCFF368XNE/@@download/ENCFF368XNE.bam

and sort them into the directory structure.

In addition, we use four motifs from the used-for-all-TFs directory of our motif collection.

Afterwards, the directory structure should look like

.:
Catchitt.jar
GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta
GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta.fai

./astrocytes:
ENCFF183YLB.bed
ENCFF600CYD.bed
ENCFF901UBX.bigWig
ENCFF384CCQ.bam

./fibroblasts:
ENCFF652HJH.bigWig
ENCFF368XNE.bam

./motifs/CTCF/:
CTCF_HUMAN.H11MO.0.A.pwm

./motifs/CTCF_Slim:
Ctcf_H1hesc_shift20_bdeu_order-20_comp1-model-1.xml

./motifs/JUND_Slim:
Jund_K562_shift20_bdeu_order-20_comp1-model-1.xml

./motifs/MAX_Slim:
Max_K562_shift20_bdeu_order-20_comp1-model-1.xml

./motifs/SP1:
ENCSR000BHK_SP1-human_1_hg19-model-2.xml

Now, we first compute the DNase-seq features from the BAM files using the "access" tool:

java -jar Catchitt.jar access i=astrocytes/ENCFF384CCQ.bam b=50 outdir=astrocytes/access_bam/
java -jar Catchitt.jar access i=fibroblasts/ENCFF368XNE.bam b=50 outdir=fibroblasts/access_bam/

We also compute the motif-based features from the additional motif files. For the PWM model of SP1, we switch the input format to Dimont XMLs but still use the low-memory version of "motif" that we also used for the HOCOMOCO PWM:

java -jar Catchitt.jar motif d=motifs/SP1/ENCSR000BHK_SP1-human_1_hg19-model-2.xml\
    g=GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta f=GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta.fai\
    b=50 outdir=motifs/SP1 threads=3

The remaining motif models are Slim models, which are substantially more complex than PWMs. While scans for these models could be accomplished by the low-memory version of "motif" as well, this would require substantial runtime. Hence, we switch off the low-memory option in this case, which, in turn, requires to increase the memory reserved by Java:

java -jar -Xms512M -Xmx64G Catchitt.jar motif d=motifs/CTCF_Slim/Ctcf_H1hesc_shift20_bdeu_order-20_comp1-model-1.xml\
    g=GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta f=GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta.fai\
    b=50 outdir=motifs/CTCF_Slim l=false threads=3
java -jar -Xms512M -Xmx64G Catchitt.jar motif d=motifs/JUND_Slim/Jund_K562_shift20_bdeu_order-20_comp1-model-1.xml\
    g=GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta f=GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta.fai\
    b=50 outdir=motifs/JUND_Slim l=false threads=3
java -jar -Xms512M -Xmx64G Catchitt.jar motif d=motifs/MAX_Slim/Max_K562_shift20_bdeu_order-20_comp1-model-1.xml\\
    g=GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta f=GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta.fai\
    b=50 outdir=motifs/MAX_Slim l=false threads=3

Finally, we start the iterative training using the new feature files:

java -jar Catchitt.jar itrain a=astrocytes/access_bam/Chromatin_accessibility.tsv.gz\
    m=motifs/CTCF/Motif_scores.tsv.gz m=motifs/CTCF_Slim/Motif_scores.tsv.gz m=motifs/JUND_Slim/Motif_scores.tsv.gz\
    m=motifs/MAX_Slim/Motif_scores.tsv.gz m=motifs/SP1/Motif_scores.tsv.gz l=astrocytes/labels/Labels.tsv.gz\
    f=GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta.fai b=50\
    t='chr2,chr3,chr4,chr5,chr6,chr7,chr9,chr10,chr11,chr12,chr13,chr14,chr15,chr16,chr17,chr17,chr18,chr19,chr20,chr22'\
    itc='chr10,chr11,chr12,chr13,chr14' outdir=astrocytes/itrain_bam_5motifs threads=8

Please note that we used the parameter "m" multiple times to specify the different motif-based features files.

It is important to specify these motifs in the same order when calling the "predict" afterwards, i.e.

java -jar Catchitt.jar predict c=astrocytes/itrain_bam_5motifs/Classifiers.xml a=fibroblasts/access_bam/Chromatin_accessibility.tsv.gz\
    m=motifs/CTCF/Motif_scores.tsv.gz m=motifs/CTCF_Slim/Motif_scores.tsv.gz m=motifs/JUND_Slim/Motif_scores.tsv.gz\
    m=motifs/MAX_Slim/Motif_scores.tsv.gz m=motifs/SP1/Motif_scores.tsv.gz\
    f=GRCh38_no_alt_analysis_set_GCA_000001405.15.fasta.fai p="chr8" outdir=fibroblasts/predict_bam_5motifs

The predictions based on the BAM files and the five motifs are then available from the file fibroblasts/predict_bam_5motifs/Predictions.tsv.gz in the format explained previously.

Version history

• Catchitt v0.1.1: Bugfixes for border cases; reduced debugging output

• Catchitt v0.1: Initial release