def make_example(read, ref_bases):
"""Create a tf.Example for read and ref_bases.
Args:
read: nucleus.Read proto with cigar, fragment_name, and aligned_sequence.
ref_bases: str. The reference bases for read.
Returns:
A tf.Example protobuf with the following features:
read_name - for debugging convenience
cigar - the cigar string of the read
read_sequence - the bases observed by the instrument
read_qualities - the quality scores emitted by the instrument, as
phred-scaled integer values.
true_sequence - the "true" bases that should have been observed for this
read, as extracted from the reference genome.
"""
# Create our example proto.
example = example_pb2.Example()
# Set the features in our Example.
# Note that the str(...) calls are necessary because proto string fields are
# unicode objects and we can only add bytes to the bytes_list.
features = example.features
features.feature['read_name'].bytes_list.value.append(
str(read.fragment_name))
features.feature['cigar'].bytes_list.value.append(
cigar.format_cigar_units(read.alignment.cigar))
features.feature['read_sequence'].bytes_list.value.append(
str(read.aligned_sequence))
features.feature['read_qualities'].int64_list.value.extend(
read.aligned_quality)
features.feature['true_sequence'].bytes_list.value.append(ref_bases)
return example
def test_to_cigar_units(self, to_convert, expected):
# We can convert the raw form.
to_convert = list(to_convert)
expected = list(expected)
actual = cigar.to_cigar_units(to_convert)
self.assertEqual(actual, expected)
# We can also convert the string form by formatting actual.
self.assertEqual(
cigar.to_cigar_units(cigar.format_cigar_units(actual)), expected)
def test_format_cigar_units(self, cigar_units, expected):
self.assertEqual(cigar.format_cigar_units(cigar_units), expected)
def make_ngs_error_examples(ref_path,
vcf_path,
bam_path,
examples_out_path,
max_reads=None):
"""Driver program for ngs_errors.
See module description for details.
Args:
ref_path: str. A path to an indexed fasta file.
vcf_path: str. A path to an indexed VCF file.
bam_path: str. A path to an SAM/BAM file.
examples_out_path: str. A path where we will write out examples.
max_reads: int or None. If not None, we will emit at most max_reads examples
to examples_out_path.
"""
# Create a ref_reader backed by ref.
ref_reader = fasta.IndexedFastaReader(ref_path)
# Create a vcf_reader backed by vcf.
vcf_reader = vcf.VcfReader(vcf_path)
# Create a sam_reader backed by bam. Provide an empty ReadRequirements
# proto to the reader so it enables standard filtering based on the default
# values of ReadRequirements. Also explicitly allow the reader to access an
# unindexed BAM, so only the iterate() function is enabled.
read_requirements = reads_pb2.ReadRequirements()
sam_reader = sam.SamReader(bam_path, read_requirements=read_requirements)
# Create our TFRecordWriter where we'll send our tf.Examples.
examples_out = genomics_writer.TFRecordWriter(examples_out_path)
# All our readers and writers are context managers, so use the `with`
# construct to open all of the inputs/outputs and close them when we are done
# looping over our reads.
n_examples = 0
with ref_reader, vcf_reader, sam_reader, examples_out:
# Loop over the reads in our BAM file:
for i, read in enumerate(sam_reader.iterate(), start=1):
# Get the Range proto describing the chrom/start/stop spanned by our read.
read_range = utils.read_range(read)
# Get all of the variants that overlap our read range.
variants = list(vcf_reader.query(read_range))
# Get the reference bases spanned by our read.
ref_bases = ref_reader.query(read_range)
# Check that we can use our read for generating an example.
if is_usable_training_example(read, variants, ref_bases):
n_examples += 1
# Convert read and ref_bases to a tf.Example with make_example.
example = make_example(read, ref_bases)
# And write it out to our TFRecord output file.
examples_out.write(example)
# Do a bit of convenient logging. This is very verbose if we convert a
# lot of reads...
logging.info((
'Added an example for read %s (span=%s) with cigar %s [%d added '
'of %d total reads]'), read.fragment_name,
ranges.to_literal(read_range),
cigar.format_cigar_units(read.alignment.cigar),
n_examples, i)
if max_reads is not None and n_examples >= max_reads:
return