Biol425 2018

From QiuLab
Jump to navigation Jump to search
Computational Molecular Biology (BIOL 425/790.49, Spring 2019)
Instructor: Dr Konstantinos Krampis, Associate Professor of Biology
Room:1001B HN (10th Floor, North Building, Computer Science Department, Linux Lab FAQ)
Class Hours: Wednesdays 10:10 am-12:40 pm
Office Hours & Address: Thursdays 4pm - 6pm -- Address: Belfer Research Building, 413 East 69th Street (between York and 1st Avenue), New York, NY 10021. Wednesdays 10:10 am-12:40 pm Direction via Google Map;
IMPORTANT: LINUX INSTRUCTIONS AND ACCESSING COMPUTERS REMOTELY

Course Schedule (All Wednesdays)

January 30st. Course overview & Unix tools

  • Course Overview. Lecture slides:
    File:Sildes-02-03-2016.pdf
  • Learning Goals: (1) Understand the "Omics" files; (2) Review/Learn Unix tools
  • In-Class Tutorial: Unix file filters
  1. Without changing directory, long-list genome, transcriptome, and proteome files using ls
  2. Without changing directory, view genome, transcriptome, and proteome files using less -S
  3. Using grep, find out the size of Borrelia burgdorferi B31 genome in terms of the number of replicons ("GBB.1con" file)
  4. Using sort, sort the replicons by (a) contig id (3rd field, numerically); and (b) replicon type (4th field)
  5. Using cut, show only the (a) contig id (3rd field); (b) replicon type (4th field)
  6. Using tr, (a) replace "_" with "|"; (b) remove ">"
  7. Using sed, (a) replace "Borrelia" with abbreviation "B."; (b) remove "plasmid" from all lines
  8. Using paste -s, extract all contig ids and concatenate them with ";"
  9. Using a combination of cut and uniq, count how many circular plasmids ("cp") and how many linear plasmids ("lp")
  • In-Class Challenges
  1. Using the "GBB.seq" file, find out the number of genes on each plasmid
grep ">" ../../bio425/data/GBB.seq | cut -c1-4| sort | uniq -c
  1. Using the "ge.dat" file, find out (a) the number of genes; (b) the number of cell lines; (c) the expression values of three genes: ERBB2, ESR1, and PGR
grep -v "Description" ../../bio425/data/ge.dat | wc -l; or:  grep -vc "Description" ../../bio425/data/ge.dat
grep "Description" ../../bio425/data/ge.dat | tr '\t' '\n'| grep -v "Desc" | wc -l
grep -Pw "ERBB2|PGR|ESR1" ../../bio425/data/ge.dat

Reading Material

Lecture slides:

File:Sildes-02-03-2016.pdf


Unix 1a: Unix 1a
Unix 1b: Unix 1b
Unix 2: Unix 2
Unix 3: Unix 3

Assignment #1 - (Due Wednesday February 06, at 10am - Submit Responses on Blackboard as document with all command line outputs)
Unix Text Filters (10 pts) Show both commands and outputs for the following questions:
 Tip1: piping to the wc command (read the help for it !) allows you to do line counts

Tip2: read the help for head command (what does the -n operator do?). If you specify head to get 1000 lines for example, you can then use tail command to get the last 10 of those 1000
Tip3: Reading material should tell you what the tr command does, but also look at tr --help. Can you use cut instead of tr ?

  1. Without changing directory (i.e., remain in your home directory), locate and long-list the genbank file named "GBB.gb" in the course data directory
  2. Count the total number of lines, show the first and last 10 lines of the file. Using a combination of head and tail commands, show only the lines containing the translated protein sequence of the first gene
  3. Count the total number of replicans by extracting lines containing "LOCUS" (case sensitive); sort them by the total number of bases ("bp")
  4. Remove the string "(plasmid" from the above output
  5. Extract the second column (replicon names) from the above output. [Hint: these fields are delimited by an unequal number of spaces, not by tabs. Use tr -s to first squeeze to single space]

February 6. Genomics (1): Gene-Finding

  • Learning goals: (1) Running UNIX programs; (2) Parse text with Perl anonymous hash
  • Lecture slides:
    File:Slides-2-10-2016.pdf
  • In-Class Tutorials
  1. Identify ORFs in a prokaryote genome
    1. Go to NCBI ORF Finder page
    2. Paste in the GenBank Accession: AE000791.1 and click "orfFind"
    3. Change minimum length for ORFs to "300" and click "Redraw". How many genes are predicted? What is the reading frame for each ORF? Coordinates? Coding direction?
    4. Click "Six Frames" to show positions of stop codons (magenta) and start codons (cyan)
  2. Gene finder using GLIMMER
    1. Locate the GLIMMER executables: ls /data/biocs/b/bio425/bin/
    2. Locate Borrelia genome files: ls /data/biocs/b/bio425/data/GBB.1con-splitted/
    3. Predict ORFs: ../../bio425/bin/long-orfs ../../bio425/data/GBB.1con-splitted/Borrelia_burgdorferi_4041_cp9_plasmid_C.fas cp9.coord [Note the two arguments: one input file and the other output filename]
    4. Open output file with cat cp9.coord. Compare results with those from NCBI ORF Finder.
    5. Extract lines with coordinates" grep "^[0-9]" cp9.coord > cp9.coord2
    6. Extract sequences into a FASTA file: ../../bio425/bin/extract ../../bio425/data/GBB.1con-splitted/Borrelia_burgdorferi_4041_cp9_plasmid_C.fas cp9.coord2 > cp9.fas [Note two input files and standard output, which is then redirected (i.e., saved) into a new file]
  3. bioseq
    1. Add bp-utils into $PATH by editing the .bash_profile file and run source .bash_profile
    2. Run bioseq with these options: -l, -n, -c, -r, -t1, -t, -t6, and -s
    3. In-Class Challenge: use bioseq to extract and translate the 1st (+1 frame) and 5th (-1 frame) genes.
cp ../../bio425/data/GBB.1con-splitted/Borrelia_burgdorferi_4041_cp9_plasmid_C.fas cp9.plasmid.fas # copy plasmid sequence
bioseq -s'163,1272' cp9.plasmid.fas | bioseq -t1 # extract first predicted ORF (+1 frame)
bioseq -s'3853,4377' cp9.plasmid.fas | bioseq -r | bioseq -t1 # extract 5th ORF (since it is -1 frame, need to rev-com before translation
Assignment #2 (Due Wednesday February 13, at 10am - Submit Responses on Blackboard)
UNIX Exercises and Reading Material (10 pts)

Lecture Videos

  1. Using ssh, log into eniac.cs.hunter.cuny.edu & then ssh into another host (e.g. "cslab8") for the exercises - REQUIRED IF YOU ARE WORKING REMOTELY!
  2. Copy data file ../../bio425/data/mystery_seq1.fas into your home directry
  3. Add /data/biocs/b/bio425/bin to your the $PATH variable in the ".bash_profile" file (using vi or emacs).
  4. Run source ~/.bash_profile to activate the above path
  5. Use the long-orf command to predict ORFs on the mystery_seq1. Save resulting coord file as "mystery_seq1.coord".
  6. Extract ONLY the lines containing ORF information into a new file "mystery_seq1.coord2" using grep
  7. Run extract to extract FASTA sequences of all predicted ORFs. Save as "mys.nuc".
  8. Translate "mys.nuc" with bioseq -t1. Save to "mys.pep" (don't be surprised if the 2nd sequence contains internal stop codons)
  9. Use bioseq to extract the ORF sequences, save as "mys.nuc2"
  10. Translate "mys.nuc2" with bioseq -t1. Save to "mys.pep2". This file should NOT contain any internal stop codons.

Note: Show all commands and outputs.To log off, type "exit" twice (first log out of the "cslab" host, 2nd time log off the "eniac" host).

February 13. Genomics (2): BASH & BLAST

  • Lecture Slides:
    File:02-17-2015.pdf
  • Learning goal: (1) BASH scripting; (2) Homology searching with NCBI blast
  • In-Class exercises
  1. Build workflow with BASH scripts
#!/usr/bin/bash
bioseq -s"163,1272" cp9.plasmid.fas > gene-0001.nuc;
bioseq -t1 gene-0001.nuc > gene-0001.pep;
exit;

Save the above as "extract-gene-v1.bash". Make it executable with chomd +x extract-gene-v1.bash. Run it with ./extract-gene-v1.bash

  1. Improvement 1. make it work for other genes (by using variables)
#!/usr/bin/bash
id=$1;
begin=$2;
end=$3;
bioseq -s"$begin,$end" cp9.plasmid.fas > gene-$id.nuc;
bioseq -t1 gene-$1.nuc > gene-$id.pep;
exit;

Save the above as "extract-gene-v2.bash". Make it executable with chomd +x extract-gene-v2.bash. Run it with ./extract-gene-v2.bash 0001 163 1272 (Note three arguments). Question: How to modify the code to make it work for genes encoded on the reverse strand?

  1. Improvement 2. make it work for both positive and negative genes (by using an "if" statement)
#!/usr/bin/bash
id=$1;
begin=$2;
end=$3;
strand=$4;
bioseq -s"$begin,$end" cp9.plasmid.fas > gene-$id.nuc;
if [ $strand -gt 0 ]; then
    bioseq -t1 gene-$1.nuc > gene-$id.pep;
else
    bioseq -r gene-$1.nuc > gene-$id.rev;
    bioseq -t1 gene-$1.rev > gene-$id.pep;
fi;
exit;
  1. Improvement 3. Make it read "cp9.coord" as an input file, by using a "while" loop:
#!/usr/bin/bash
cat $1 | grep "^[0-9]" | while read line; do
    id=$(echo $line | cut -f1 -d' '); # run commands and save result to a variable
    x1=$(echo $line | cut -f2 -d' ');
    x2=$(echo $line | cut -f3 -d' ');
    strand=$(echo $line | cut -f4 -d' ');
    if [ $strand -lt 0 ]; then
        bioseq -s"$x2,$x1" cp9.plasmid.fas > gene-$id.nuc;
        bioseq -r gene-$id.nuc > gene-$id.rev;
        bioseq -t1 gene-$id.rev;
    else
        bioseq -s"$x1,$x2" cp9.plasmid.fas > gene-$id.nuc;
        bioseq -t1 gene-$id.nuc;
    fi;
done;
exit;
  1. Run Stand-alone BLAST:
  • Add blast binaries to your $PATH in ".bash_profile": export PATH=$PATH:/data/biocs/b/bio425/ncbi-blast-2.2.30+/bin/
  • BLAST tutorial 1. A single unknown sequence against a reference genome
cp ../../bio425/data/GBB.pep ~/. # Copy the reference genome
cp ../../bio425/data/unknown.pep ~/. # Copy the query sequence
makeblastdb -in GBB.pep -dbtype prot -parse_seqids -out ref # make a database of reference genome
blastp -query unknown.pep -db ref # Run simple protein blast
blastp -query unknown.pep -db ref -evalue 1e-5 # filter by E values
blastp -query unknown.pep -db ref -evalue 1e-5 -outfmt 6 # concise output
blastp -query unknown.pep -db ref -evalue 1e-5 -outfmt 6 | cut -f2 > homologs-in-ref.txt # save a list of homologs
blastdbcmd -db ref -entry_batch homologs-in-ref.txt > homologs.pep # extract homolog sequences
  • In-Class challenges
Assignment #3 (Due Wednesday February 20, at 10am - Submit Responses on Blackboard)
Assignment (10 pts)

IMPORTANT: Log on your eniac account and then ssh into a "cslab" host (e.g., ssh cslab5). Perform the following tasks without changing directory (i.e., stay in your home directory).


  1. UNIX filter exercises (4 pts)
    1. For the codon file /data/biocs/b/bio425/data/codon.table.T, sort by single-letter code of amino acids
    2. use "grep" to show only codons that start with an "A"
    3. Show all codons for "Arg", without amino acid symbols
    4. Use an editor, compose a BASH script (name it "read-codon.bash") that uses a "while" loop to read each line of this file. First, use "grep -v" to exclude stop codons. Then, create three variables to capture the values of three elements on each line. For each line, print the output in the following format: "AAA codes for Lys (K)".
  2. Exercise for the use of wildcard & BASH "for" loop ( 3 pts)
    1. Long-list (i.e., ls -l) the following file in the "/data/biocs/b/bio425/data/GBB.1con-splitted/" directory: Borrelia_burgdorferi_3615_main.fas (this file contains the main chromosome sequence of the B31 strain of Lyme disease bacteria). Run bioseq -l to find out the length of this sequence.
    2. Without changing directory, long-list ALL files with the ".fas" suffix in the same directory (using wildcard). This command list all replicons (sequences in the .fas files, which are chromosome and 21 plasminds) of this genome.
    3. Write a BASH "for" loop on the command line (do not use an editor) to obtain length of each replicon using bioseq -l
  3. BLAST exercise (3 pts).
    1. Use "blastp" to identify matches of the sequence ../../bio425/data/unknown.pep in the "ref" database (which was created in class), using an e-value cutoff of 1e-10
    2. Show all pairwise alignments
    3. Show output in a tabular format (using "-outfmt 6")
    4. Explain the following blast terms: "Identity", "Positives", and "Expect". [Hint, visit the NCBI BLAST home page and this FAQ].

February 20 and February 27. Genomics (3). Genome BLAST & BioPerl

  • Lecture Slides:
    File:02-24-2016.pdf
  • Learning goals: Homology, BLAST, & Object-oriented programming with Perl
  • BLAST tutorial 1. A single unknown sequence against a reference genome.
  • Run Stand-alone BLAST:
  • Add blast binaries to your $PATH in ".bash_profile": export PATH=$PATH:/data/biocs/b/bio425/ncbi-blast-2.2.30+/bin/
cp ../../bio425/data/GBB.pep ~/. # Copy the reference genome
cp ../../bio425/data/unknown.pep ~/. # Copy the query sequence
makeblastdb -in GBB.pep -dbtype prot -parse_seqids -out ref # make a database of reference genome
blastp -query unknown.pep -db ref # Run simple protein blast
blastp -query unknown.pep -db ref -evalue 1e-5 # filter by E values
blastp -query unknown.pep -db ref -evalue 1e-5 -outfmt 6 # concise output
blastp -query unknown.pep -db ref -evalue 1e-5 -outfmt 6 | cut -f2 > homologs-in-ref.txt # save a list of homologs
blastdbcmd -db ref -entry_batch homologs-in-ref.txt > homologs.pep # extract homolog sequences
  • BLAST tutorial 2.
  • Find homologs within the new genome itself
cp ../../bio425/data/N40.pep ~/. # Copy the unknown genome
makeblastdb -in N40.pep -dbtype prot -parse_seqids -out N40 # make a database of the new genome
blastp -query unknown.pep -db N40 -evalue 1e-5 -outfmt 6 | cut -f2 > homologs-in-N40.txt # find homologs in the new genome
blastdbcmd -db N40 -entry_batch homologs-in-N40.txt >> homologs.pep # append to homolog sequences
  • BLAST tutorial 3.
  • Multiple alignment & build a phylogeny
../../bio425/bin/muscle -in homologs.pep -out homologs.aln # align sequences
cat homologs.aln | tr ':' '_' > homologs2.aln
../../bio425/bin/FastTree homologs2.aln > homologs.tree # build a gene tree
../../bio425/figtree &  # view tree (works only in the lab; install your own copy if working remotely)
Assignment #4 (Due Wednesday March 6, at 10am - Submit Responses on Blackboard)
BLAST exercise (5 pts)

Run BLASTp to identify all homologs of BBA18 in the reference genome ("ref").

  1. Obtain BBA18 peptide sequence using blastdbcmd -db ref -entry 'BBA18'.
  2. Run blastp against the "ref" database with the following e-value cutoffs: 1e-5, 1e-3, and 1e-1. Submit the results for 1e-3 with the "-outfmt 6" option.
  3. Extract all homologs using blastdbcmd
  4. Combine all sequences with cat and align all sequences using muscle. Show alignment.
  5. Build a tree of homologs using FastTree. Display tree with evolview.

Perl exercise' (5 pts)

  1. Compose a Perl script shown below ("dump-coords.pl" in our files), which uses an array (@genes) to hold information for two genes in the ../../bio425/data/mys.coord2 file. Each element of the array would be a reference to a hash. The hash reference itself would hold gene information in the following format: e.g., $gene={'id'=>'0001', 'start'=>16, 'end'=>324, 'frame'=>'+1', 'score'=>0.929}. Print the array by using the Dumper function.

Do not hard-code the values of the hash within the code only the keys (id, start, stop, frame, score), the script must parse the data for the values from the file! Tip: read elements of line into array, then construct anonymous hash (with $ not %) hashes using values from the elements of the array, and then push the anonymous hash to the @genes array. Remember you will need an intermediate array which will hold the information for the elements of each line, and will be "reloaded with each line. Use the following skeleton code : 

#!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper; # print complex data structure
# ----------------------------------------
# Author          : WGQ
# Date            : February 30, 2015
# Description     : Read coord file
# Input           : A coord file
# Output          : Coordinates and read frame for each gene
# ----------------------------------------
my @genes; # declare the array
while(<>) { # this means that as long as lines come from the pipe we keep going
  my $line = $_; # a line that come from the pipe (we go line by line)
  next unless $line =~ /^\d+/; # skip lines except those reporting genes 
  <Your code: split the $line on white spaces and save into variables>
  <Your code: construct anonymous hash and push into @genes>
}
print Dumper(\@genes);
exit;

March 6 & March 13: Genomics + Object-oriented Perl (Continued)

  • Learning goal: (1) Object-Oriented Perl; (2) BioPerl
  • In-Class Exercises

Construct and dump a Bio::Seq object 

#!/usr/bin/perl -w
use strict;
use lib '/data/biocs/b/bio425/bioperl-live'; 
use Bio::Seq;
use Data::Dumper;
my $seq_obj = Bio::Seq->new( -id => "ospC", -seq =>"tgtaataattcaggaaaaga" );
print Dumper($seq_obj);
exit;

Apply Bio::Seq methods: 

my $seq_rev=$seq_obj->revcom()->seq(); # reverse-complement & get sequence string
my $eq_length=$seq_obj->length(); 
my $seq_id=$seq_obj->display_id(); 
my $seq_string=$seq_obj->seq(); # get sequence string
my $seq_translate=$seq_obj->translate()->seq(); # translate & get sequence string
my $subseq1 = $seq_obj->subseq(1,10); # subseq() returns a string
my $subseq2= $seq_obj->trunc(1,10)->seq(); # trunc() returns a truncated Bio::Seq object
  • Challenge 1: Write a BioPerl-based script called "bioperl-exercise.pl". Start by constructing a Bio::Seq object using the "mystery_seq1.fas" sequence. Apply the trunc() method to obtain a coding segment from base #308 to #751. Reverse-complement and then translate the segment. Output the translated protein sequence.
#!/usr/bin/perl -w
use strict;
use lib '/data/biocs/b/bio425/bioperl-live'; 
use Bio::Seq;
my $seq_obj = Bio::Seq->new( -id => "mystery_seq", -seq =>"tgtaataattcaggaaaaga.............." );
print $seq_obj->trunc(308, 751)->revcom()->translate()->seq(), "\n";
exit;
  • Challenge 2. Re-write the above code using Bio::SeqIO to read the "mystery_seq1.fas" sequence and output the protein sequence.
#!/usr/bin/perl -w
use strict;
use lib '/data/biocs/b/bio425/bioperl-live'; 
use Bio::SeqIO;
die "$0 <fasta_file>\n" unless @ARGV == 1;
my $file = shift @ARGV; 
my $input = Bio::Seq->new( -file => $file, -format =>"fasta" );
my $seq_obj = $input->next_seq();
print $seq_obj->trunc(308, 751)->revcom()->translate()->seq(), "\n";
exit;
Assignment #5 (Due Wednesday March 20, at 10am - Submit Responses on Blackboard)
BioPerl exercises (10 pts)

Perl exercise 1 (if you have submitted this before, please resubmit your earlier answer and note that is a resubmission) (5 pts)

  1. Compose a Perl script shown below ("dump-coords.pl" in our files), which uses an array (@genes) to hold information for two genes in the ../../bio425/data/mys.coord2 file. Each element of the array would be a reference to a hash. The hash reference itself would hold gene information in the following format: e.g., $gene={'id'=>'0001', 'start'=>16, 'end'=>324, 'frame'=>'+1', 'score'=>0.929}. Print the array by using the Dumper function.

Do not hard-code the values of the hash within the code only the keys (id, start, stop, frame, score), the script must parse the data for the values from the file! Tip: read elements of line into array, then construct anonymous hash (with $ not %) hashes using values from the elements of the array, and then push the anonymous hash to the @genes array. Remember you will need an intermediate array which will hold the information for the elements of each line, and will be "reloaded with each line. Use the following skeleton code : 

#!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper; # print complex data structure
# ----------------------------------------
# Author          : WGQ
# Date            : February 30, 2015
# Description     : Read coord file
# Input           : A coord file
# Output          : Coordinates and read frame for each gene
# ----------------------------------------
my @genes; # declare the array
while(<>) { # this means that as long as lines come from the pipe we keep going
  my $line = $_; # a line that come from the pipe (we go line by line)
  next unless $line =~ /^\d+/; # skip lines except those reporting genes 
  <Your code: split the $line on white spaces and save into variables>
  <Your code: construct anonymous hash and push into @genes>
}
print Dumper(\@genes);
exit;


Perl exercise 2 (5 pts)

  1. Write an "extract.pl" using Perl & BioPerl that extract coding sequences from "coord" files. The script will use Bio::SeqIO to read the genome FASTA file ("mystery_seq1.fas", see Assignment #2 above). It will also read the "mystery_seq1.coord" (see Assignment #2 above) as the 2nd argument. Use Bio::Seq to obtain coding sequences and translate sequences. Your output of protein sequences should not contain stop codons except as the last codon. The following template helps you get started:
#!/usr/bin/perl
use strict;
use warnings;
use lib '/data/biocs/b/bio425/bioperl-live';
use Bio::SeqIO;
# ----------------------------------------
# File            : extract.pl
# Author          : WGQ
# Date            : March 5, 2015
# Description     : Emulate glimmer EXTRACT program
# Input           : A FASTA file with 1 DNA seq and coord file from LONG-ORF
# Output          : A FASTA file with translated protein sequences
# ----------------------------------------
die "Usage: $0 <FASTA_file> <coord_file>\n" unless @ARGV > 0;
my ($fasta_file, $coord_file) = @ARGV;
my $fasta_input = Bio::SeqIO->new(<your code>); # create a file handle to read sequences from a file
my $output = Bio::SeqIO->new(-file=>">$fasta_file".".out", -format=>'fasta'); # create a file handle to output sequences into a file
my $seq_obj = $input->next_seq(); # get sequence object from FASTA file
# Read COORD file & extract sequences
open COORD, "<" . $coord_file;
while (<COORD>) {
      my $line = $_;
      chomp $line;
      next unless $line =~ /^\d+/; # skip lines except
      my ($seq_id, $cor1, $cor2, $strand, $score) = split /\s+/, $line; # split line on white spaces
      if (<your code: if strand is positive>) {
        <your code: use trunc function to get sub-sequence as an object>
      } else {
        <your code: use the trunc() function to get sub-sequence as an object>
        <your code: use the revcom() function to reverse-complement the seq object>
      }
      <your code: use translate() function to obtain protein sequence as an abject, "$pro_obj">
      $output->write_seq($pro_obj);
}
close COORD;
exit;

March 20 and 27: Course Material Covered Thus Far on Unix, Additional BioPerl topics

  • Practice Tests
  1. Browse & Filter "Big Data" files with UNIX filters
    1. Genome file
      1. List all FASTA files in the "../../bio425/data" directory: ls ../../bio425/data/*.fas
      2. Count number of sequences in a FASTA file: "../../bio425/data/GBB.pep": grep -c ">" ../../bio425/data/GBB.pep
      3. Count number of sequences in all FASTA file in this directory: grep -c ">" ../../bio425/data/*.fas
      4. Remove directory names from the above output: grep ">" ../../bio425/data/*.fas | sed 's/^.\+data\///' or grep ">" ../../bio425/data/*.fas| cut -f5 -d'/'
    2. GenBank file
      1. Show top 10 lines in "../../bio425/data/mdm2.gb": head ../../bio425/data/mdm2.gb
      2. Show bottom 10 lines: tail ../../bio425/data/mdm2.gb
      3. Extract all lines containing nucleotides: cat ../../bio425/data/mdm2.gb | grep -P "^\s+\d+[atcg\s]+$"
    3. Transcriptome file: a microarray data set
      1. Count the number of lines in "../../bio425/data/ge.dat": wc -l ../../bio425/data/ge.dat
      2. Count the number of genes: cut -f1 ../../bio425/data/ge.dat | grep -vc "Desc"
      3. Count the number of cells: head -1 ../../bio425/data/ge.dat | tr '\t' '\n' | grep -vc "Desc"
    4. Transcriptome file: an RNA-SEQ output file
      1. Count the nubmer of lines in "../../bio425/data/gene_exp.diff": wc -l ../../bio425/data/gene_exp.diff
      2. Show head: head ../../bio425/data/gene_exp.diff
      3. Show tail: tail ../../bio425/data/gene_exp.diff
      4. Count nubmer of "OK" gene pairs (valid comparisons): grep -c "OK" ../../bio425/data/gene_exp.diff
      5. Count nubmer of significantly different genes: grep -c "yes$" ../../bio425/data/gene_exp.diff
      6. Sort by "log2(fold_change)": grep "yes$" ../../bio425/data/gene_exp.diff | cut -f1,10 | sort -k2 -n
    5. A proteomics dataset: SILAC
      1. Count the number of line in "../../bio425/data/Jill-silac-batch-1.dat": wc -l ../../bio425/data/Jill-silac-batch-1.dat
      2. Show top: head ../../bio425/data/Jill-silac-batch-1.dat
      3. Show bottom: wc -l ../../bio425/data/Jill-silac-batch-1.dat
      4. Show results for P53 genes: grep -w "TP53" ../../bio425/data/Jill-silac-batch-1.dat
      5. Sort by "log_a_b_ratio": sort -k5 -n ../../bio425/data/Jill-silac-batch-1.dat
      6. Show ranking of P53: sort -k5 -n -r ../../bio425/data/Jill-silac-batch-1.dat | cat -n | grep -w "TP53"


Important information for solving the homework ! BioPerl Lecture videos


Assignment #6 - (Due Wednesday 4/27/2018, at 10am - Submit Responses on Blackboard)
Unix Text Filters (5 pts) Show both commands and outputs for the following questions:
  1. Identify homologs and build a phylogeny
    1. Copy genome file: "../../bio425/data/GBB.1con-splitted/Borrelia_burgdorferi_4075_lp54_plasmid_A.fas" to your home directory as "lp54.fas": cp ../../bio425/data/GBB.1con-splitted/Borrelia_burgdorferi_4075_lp54_plasmid_A.fas lp54.fas
    2. Identify ORFs in file using "long-orfs": long-orfs lp54.fas lp54.coord
    3. Extract nucleotide sequences: extract lp54.fas lp54.coord > lp54.nuc
    4. Use "bioseq" to translate into peptides, into "lp54.pep": bioseq -t1 lp54.nuc > lp54.pep
    5. Make a blast database: makeblastdb -in lp54.pep -dbtype 'prot' -parse_seqids -out lp54
    6. Copy file "../../bio425/data/BBA68.pep" to your home directory: cp ../../bio425/data/BBA68.pep .
    7. Find homologs of "BBA68.pep" in "lp54.pep" using "blastp": blastp -query BBA68.pep -db lp54 -evalue 1e-5 -outfmt 6 | cut -f2 > BBA68.homologs
    8. Extract all blast homologs using "blastdbcmd": blastdbcmd -db lp54 -entry_batch BBA68.homologs > BBA68.homologs.pep
    9. Align all homologs using "muscle": muscle -in BBA68.homologs.pep -out BBA68.homologs.aligned
    10. Build a tree of BBA65 homologs using "FastTree": FastTree BBA68.homologs.aligned > BBA68.dnd
    11. Show tree with evolview
  2. Review BASH "while" & "for" loops (see Assignment #3)
  3. Review the use Bio::SeqIO to read FASTA files and the use Bio::Seq methods to manipulate sequences (see Assignment #5)

Perl exercises (5 pts)

  • Write an "extract.pl" using Perl & BioPerl that extract coding sequences from "coord" files. The script will use Bio::SeqIO to read the genome FASTA file ("mystery_seq1.fas", see Assignment #2 above). It will also read the "mystery_seq1.coord" (see Assignment #2 above) as the 2nd argument. Use Bio::Seq to obtain coding sequences and translate sequences. Your output of protein sequences should not contain stop codons except as the last codon. The following template helps you get started:
!/usr/bin/perl
use strict;
use warnings;
use lib '/data/biocs/b/bio425/bioperl-live';
use Bio::SeqIO;
# ----------------------------------------
# File            : extract.pl
# Author          : WGQ
# Date            : March 5, 2015
# Description     : Emulate glimmer EXTRACT program
# Input           : A FASTA file with 1 DNA seq and coord file from LONG-ORF
# Output          : A FASTA file with translated protein sequences
# ----------------------------------------
die "Usage: $0 <FASTA_file> <coord_file>\n" unless @ARGV > 0;
my ($fasta_file, $coord_file) = @ARGV;
my $fasta_input = Bio::SeqIO->new(<your code>); # create a file handle to read sequences from a file
my $output = Bio::SeqIO->new(-file=>">$fasta_file".".out", -format=>'fasta'); # create a file handle to output sequences into a file
my $seq_obj = $input->next_seq(); # get sequence object from FASTA file
# Read COORD file & extract sequences
open COORD, "<" . $coord_file;
while (<COORD>) {
      my $line = $_;
      chomp $line;
      next unless $line =~ /^\d+/; # skip lines except
      my ($seq_id, $cor1, $cor2, $strand, $score) = split /\s+/, $line; # split line on white spaces
      if (<your code: if strand is positive>) {
        <your code: use trunc function to get sub-sequence as an object>
      } else {
        <your code: use the trunc() function to get sub-sequence as an object>
        <your code: use the revcom() function to reverse-complement the seq object>
      }
      <your code: use translate() function to obtain protein sequence as an abject, "$pro_obj">
      $output->write_seq($pro_obj);
}
close COORD;
exit;


  • The following Perl code dumps nucleotide and codon frequencies given a coding sequence. It is based on the Bio::Tools::SeqStats module of BioPerl. Copy and run it with ./seq-stats.pl ../../bio425/data/B31_ospA.fas to understand its behavior.
#!/usr/bin/perl -w
use strict;
use lib '/data/biocs/b/bio425/bioperl-live';
use Bio::Tools::SeqStats;
use Bio::SeqIO;
use Data::Dumper;
die "Usage: $0 <fasta>\n" unless @ARGV == 1;
my $filename = shift @ARGV;
my $in = Bio::SeqIO->new(-file=>$filename, -format=>'fasta');
my $seqobj = $in->next_seq();
my $seq_stats = Bio::Tools::SeqStats->new($seqobj);
my $monomers = $seq_stats->count_monomers();
my $codons = $seq_stats->count_codons();
print Dumper($monomers, $codons);
exit;
  • Write a Perl code ("my-seq-stats.pl") to emulate its two methods ("count_monomers" & "count_codons") with the following specific requirements:
    • Read the fasta file with Bio::SeqIO
    • Write a subroutine named as "count_monomers" to count and print the frequency of each nucleotide (in percentage), sorted by nucleotide type. The argument for the subroutine would be the sequence as a string, as in count_monomers($seqobj->seq). The return value would be a reference to a hash (the same as the $monomers in the above code).
    • Hint: use hash to count unique bases, see Perl Cookbook example, especially the code listed under "4.6.2.4. Faster but different"
  • In a similar way, write a subroutine named as "count_codons" to count and print the frequency of each codon, sorted by codons. Your codon counts should be the same as those produced by the listed code.

April 3 Population Analysis

Tutorial 1. Extract SNP sites 

#!/usr/bin/perl
# Author: WGQ
# Description: Examine each alignment site as a SNP or constant
# Input:  a DNA alignment
# Output: a haplotypes alignemnt
use strict;
use warnings;
use Data::Dumper;

# Part I. Read file and store NTs in a hash (use Bio::AlignIO to read an alignment is better)
my %seqs; # declare a hash as sequence container
my $length;
while (<>) { # read file line by line
  my $line = $_;
  chomp $line;
  next unless $line =~ /^seq/; # skip lines unless it starts with "seq"
  my ($id, $seq) = split /\s+/, $line; # split on white spaces
  $seqs{$id} = [ (split //, $seq) ]; # id as key, an array of nts as value
  $length = length($seq);
}

my %is_snp; # declare a hash to store status of alignment columns
# Part II. Go through each site and report status
for (my $pos = 0; $pos < $length; $pos++) {
  my %seen_nt; # declare a hash to get counts of each nt at a aligned position
  foreach my $id (keys %seqs) { # collect and count all nts at an aligned site
    my $nt =  $seqs{$id}->[$pos];
    $seen_nt{$nt}++;
  }
  my @key_nts = keys %seen_nt;
  if (@key_nts > 1) { # a SNP site has more than two nucelotdies
    $is_snp{$pos} = 1;
  } else { # a constant site
    $is_snp{$pos} = 0;
  }
}

# Part III. Print haplotypes (i.e., nucleotides at SNP sites for each chromosome)
foreach my $id (keys %seqs) { # for each chromosome
  print $id, "\t";
  for (my $pos = 0; $pos < $length; $pos++) { # for each site
    next unless $is_snp{$pos}; # skip constant site
    print $seqs{$id}->[$pos]; # print nt at a SNP site
  }
  print "\n";
}

exit;

Tutorial 2. Hardy-Weinberg Equilibrium: Calculate expected genotype frequencies

Assignment #7 (Due April 10, at 10am - Submit Responses on Blackboard)
  • Based on the ../../bio425/data/ex3-1.aln,
  • (4 pts). Define "allele", "SNP", and "haplotype" based on the discussion we had in class and the slides. Analyze alignment by eye and do the following:
    • Label all SNP sites
    • Count frequency of each of the two alleles at the first SNP site
    • List all haplotypes, and count frequency of each haplotype.
    • How many SNP (i.e., variable) sites you expect to see in a window of DNA containing 10K bases among humans?
    • How many nucleotide states (2, 3, or 4) you expect to see for an individual SNP site?
    • Do you expect to see more or less transitons than tranvsersions?
    • More synonymous or nonsynonymous SNPs (if the sequence codes for a protein)?
  • (4 pts). Explain in a few sentences what the Perl code above does in lines 38-45
  • (2 pts). Modify the code to use Bio::AlignIO to load the sequences (even if you cannot make it fully working, do your best to write some code that shows that you understand the documentation) and how to add it in the code. For documentation see http://search.cpan.org/dist/BioPerl/Bio/AlignIO.pm

April 10 and April 17: Advanced BioPerl

Lecture Slides

Assignment #8 (Due Wednesday May 1st, at 10am - Submit Responses on Blackboard)
  • (5 pts). Use the following FASTA sequence as input (copy-paste into a vi file in your terminal) FASTA sample and then write BioPerl code to do the following:
    • Open the file with Bio:SeqIO and read it contents
    • Print the length of each sequence and the total length of all the sequences that we have in the file
    • Print the "description" and "display_id", and any other information from the methods that you see are available by reading the Bio:Seq documentation Bio:SeqIO
    • What do you observe when you print these information - which part of the FASTA header is printed ?
  • (5 pts). Use the following Genbank sequence as input (copy-paste into a vi file in your terminal) GenBank sample and then write BioPerl code to do the following:
    • Read the Genbank file using the Bio:SeqIO and the sequences using Bio::Seq
    • Check with a regular expression if the display_id contains "methyltranferase"
    • Check if the sequence has the pattern: one or more g's, followed by t and any character repeated three times, followed by at least 2 t's.
    • reverse complement the sequence and print the reverse complement
    • after reverse complement write to a FASTA file


May 1st and May 8 Regular Expressions

  • Learning goals: Perl Regular Expressions and Pattern Matching
  • Lecture slides: Lecture Slides
Assignment #9 (Due Wednesday May 15, at 10am - Submit Responses on Blackboard)
  • (5 pts). Write regular expression to parse the requested items below from the Swiss Prot file . It is important that you save the text from the link in a text file, then open the file from within a Perl script (or cat and use while <> in the Perl script), and make the el script to run the regular expression and print the exact results requested below, from within your Perl script.
    • Match and print the identifiers that look like "IPR..." from the lines that start with "DR" - just print the identifies, nothing else from the line.
    • Match and print the size (line with SQ, size is in amino acids AA) and molecular weight of the sequence (again line with SQ, MW). We want just the numbers, nothing else.
    • Match and print just the sequence - last two line lines of the file, with only the "MKKLFAS....."
  • (5 pts). Write regular expression to parse the requested items below from the NCBI File It is important that you save the text from the link in a text file, then open the file from within a Perl script (or cat and use while <> in the Perl script), and make the el script to run the regular expression and print the exact results requested below, from within your Perl script.
    • The numbers (start and end point) for a complement gene (look for a line that has both "complement" and "gene")
    • The complete TITLE (including more than one lines - your regular expression has to match past the \n)
    • The Journal volume and year (these are found in parentheses () in the line that has Journal as identifier)

May 15: Q&A on everything covered in the course - material review before FINAL

Wednesday, May 22 FINAL EXAM

General Information

Course Description

  • Background: Biomedical research is becoming a high-throughput science. As a result, information technology plays an increasingly important role in biomedical discovery. Bioinformatics is a new interdisciplinary field formed between molecular biology and computer science.
  • Contents: This course will introduce both bioinformatics theories and practices. Topics include: database searching, sequence alignment, molecular phylogenetics, structure prediction, and microarray analysis. The course is held in a UNIX-based instructional lab specifically configured for bioinformatics applications.
  • Problem-based Learning (PBL): For each session, students will work in groups to solve a set of bioinformatics problems. Instructor will serve as the facilitator rather than a lecturer. Evaluation of student performance include both active participation in the classroom work as well as quality of assignments (see #Grading Policy).
  • Learning Goals: After competing the course, students should be able to perform most common bioinformatics analysis in a biomedical research setting. Specifically, students will be able to
    • Approach biological questions evolutionarily ("Tree-thinking")
    • Evaluate and interpret computational results statistically ("Statistical-thinking")
    • Formulate informatics questions quantitatively and precisely ("Abstraction")
    • Design efficient procedures to solve problems ("Algorithm-thinking")
    • Manipulate high-volume textual data using UNIX tools, Perl/BioPerl, R, and Relational Database ("Data Visualization")
  • Pre-requisites: This 3-credit course is designed for upper-level undergraduates and graduate students. Prior experiences in the UNIX Operating System and at least one programming language are required. Hunter pre-requisites are CSCI132 (Practical Unix and Perl Programming) and BIOL300 (Biochemistry) or BIOL302 (Molecular Genetics), or permission by the instructor. Warning: This is a programming-based bioinformatics course. Working knowledge of UNIX and Perl is required for successful completion of the course.
  • Academic Honesty: Hunter College regards acts of academic dishonesty (e.g., plagiarism, cheating on examinations, obtaining unfair advantage, and falsification of records and official documents) as serious offenses against the values of intellectual honesty. The College is committed to enforcing the CUNY Policy on Academic Integrity and will pursue cases of academic dishonesty according to the Hunter College Academic Integrity Procedures.

Grading Policy

  • Treat assignments as take-home exams. Student performance will be evaluated by weekly assignments and projects. While these are take-home projects and students are allowed to work in groups and answers to some of the questions are provided in the back of the textbook, students are expected to compose the final short answers, computer commands, and code independently. There are virtually an unlimited number of ways to solve a computational problem, as are ways and personal styles to implement an algorithm. Writings and blocks of codes that are virtually exact copies between individual students will be investigated as possible cases of plagiarism (e.g., copies from the Internet, text book, or each other). In such a case, the instructor will hold closed-door exams for involved individuals. Zero credits will be given to ALL involved individuals if the instructor considers there is enough evidence for plagiarism. To avoid being investigated for plagiarism, Do NOT copy from others or let others copy your work.
  • Submit assignments on the Blackboard Email attachments will NOT be accepted. Assignments will not be allowed past the due date and time and will be graded as zero. Each assignment will be graded based on timeliness (10%), whether executable or having major errors (50%), algorithm efficiency (10%), and readability in programming styles (30%, see #Assignment Expectations).
  • The grading scheme
    • Assignments (100 pts): 10 exercises.
    • Mid-term (50 pts).
    • Final Project (50 pts)
    • Classroom performance (50 pts): Active engagement in classroom exercises and discussions
    • Attendance (50 pts): 1 unexcused absences = 40; 2 absences = 30; More than 2 = 0.

Assignment Expectations

  • Use a programming editor (e.g., vi, emacs, sublime) so you could have features like automatic syntax highlighting, indentation, and matching of quotes and parenthesis.
  • All PERL code must begin with "use strict; and use warnings;" statements. For each assignment, unless otherwise stated, I would like the full text of the source code. Since you cannot print using the text editor in the lab (even if you are connected from home), you must copy and paste the code into a word processor or a local text editor. If you are using a word processor, change the font to a fixed-width/monospace font. On Windows, this is usually Courier.
  • Also, unless otherwise stated, both the input and the output of the program must be submitted as well. This should also be in fixed-width font, and you should label it in such a way so that I know it is the program's input/output. This is so that I know that you've run the program, what data you have used, and what the program produced. If you are working from the lab, one option is to email the code to yourself, change the font, and then print it somewhere else as there is no printer in the lab.
  • Recommended Style
  • Bad Style

Useful Links

Unix Tutorials

Perl Help

  • Professor Stewart Weiss has taught CSCI132, a UNIX and Perl class. His slides go into much greater detail and are an invaluable resource. They can be found on his course page here.
  • Perl documentation at perldoc.perl.org. Besides that, running the perldoc command before either a function (with the -f option ie, perldoc -f substr) or a perl module (ie, perldoc Bio::Seq) can get you similar results without having to leave the terminal.

Regular Expression

Bioperl

SQL

Retrieved from "https://wiki.genometracker.org/index.php?title=Biol425_2018&oldid=4847"