Secuenciación de amplicones y genotipado de alto rendimiento

Secuenciación de amplicones (SA)  es una traducción aproximada al español de la técnica de "Amplicon sequencing" que junto con las tecnologías de secuenciación masiva (del inglés new generation sequencing, NGS) permite genotipar cientos/miles de individuos en un único experimento.

La secuenciación de amplicones (SA) consiste en secuenciar los productos de múltiples PCRs. Un amplicón se define como el conjunto de secuencias obtenidas de cada PCR individual.

Antiguamente se realizaban PCRs individuales y se secuenciaban uno a uno los productos. Con las nuevas técnicas de NGS, podemos incluir etiquetas de DNA (por ej. una secuencia única de 6 nucleótidos) diferentes para cientos de muestras o individuos y clasificar más tarde las secuencias o reads resultantes de una única secuenciación (Binladen et al. 2007; Meyer et al. 2007).

Esquema de etiquetado y amplificación para la secuenciación de amplicones.

Mediante esta técnica podremos genotipar individuos y distinguir los diferentes alelos (con la secuenciación tradicional a veces es complicado separar alelos de un mismo gen). El principal problema de las técnicas de NGS es su alta tasa de error, que a su vez puede ser compensada incrementando la profundidad de secuenciación (el número de reads). Otros problemas pueden ser los errores de la polimerasa o la generación de quimeras (una secuencia mezcla de otras).

En el siguiente enlace podemos ver un vídeo explicativo del proceso de secuenciación de amplicones:
http://www.jove.com/video/51709/la-secuenciacin-de-prxima-generacin-de-16s-arn-ribosomal-genes?language=Spanish

Básicamente existen 4 etapas en el análisis por AS con NGS:

1. Diseño experimental de los primers usados para amplificar los genes de interés (marcadores) y las etiquetas a usar para distinguir los diferentes individuos o muestras.
2. Amplificación por PCR de los marcadores en el laboratorio, generalmente se realiza una PCR por cada muestra.
3. Secuenciación de los productos de amplificación. Las tecnologías de NGS más usadas para SA son: Illumina, 454 e Ion Torrent.
4. Análisis bioinformático de los datos de secuenciación. El análisis incluye separación de las reads en amplicones, corrección de errores de secuenciación, filtrado de reads minoritarias/contaminantes y generación de genotipados.

Etapas de la técnica de secuenciación de amplicones mediante NGS.

Aplicaciones 

SA es utilizado para realizar clasificaciones taxonómicas usando genes como: cytochrome c oxidase subunit 1 (CO1), genes rRNA (16S/18S/28S), genes específicos de plantas (rbcL, matK, and trnH-psbA) y espaciadores internos nucleares (ITSs) (Kress et al. 2014; Joly et al. 2014). Los genes anteriores se distinguen por una tasa de mutación suficientemente rápida como para distinguir especies cercanas y a la vez suficientemente estables como para distinguir congéneres.

Lista de genes habitualmente usados como marcadores taxonómicos (fuente: Kress et al. 2014)

Un experimento pionero de SA fue la determinación de la diversidad microbiana en aguas marinas profundas (Sogin et al. 2006), usando primers flanquenado la región V6 hipervariable de la subunidad 16S rRNA bacteriana. Dicho estudio descubrió miles de poblaciones minoritarias de organismos no conocidos con anterioridad.

Otro gran campo de aplicación es el genotipado de familias de genes de alta complejidad, como el complejo mayor de histocompatibilidad, que poseen múltiples loci y diferente número de copias entre individuos, incluso de la misma especie (Babik et al. 2010; Lighten et al. 2014). El complejo mayor de histocompatibilidad (MHC) de clase I y II codifica receptores celulares que presentan antígenos a las células del sistema inmune y son los genes más polimórficos conocidos en vertebrados . El MHC humano también se conoce como HLA (Human Leukocyte Antigen) y juega un papel clave en la compatibilidad en el transplante de órganos. Los loci del MHC son tan polimórficos que no hay dos individuos en una población no endogámica que posean el mismo conjunto de alelos (excepto gemelos).

Estadísticas del número de alelos conocidos para la familia de genes del HLA (fuente: base de datos IMGT-HLA)

Hasta hace poco era necesario clonar y secuenciar uno por uno los diferentes alelos de este tipo de genes para conseguir una secuencia fiable. Actualmente tan tediosa tarea puede ser simplificada mediante un único experimento de NGS que incluya múltiples individuos y múliples genes. El secuenciador de nueva generación (ej.: Illumina, 454 o Ion Torrent) leerá las sequencias individuales de cada uno de los alelos. Actualmente existen incluso kits comerciales para simplificar el proceso: Illumina TruSeq Custom Amplicon, Roche 454 Fluidigm Access Array or Life Technologies Ion Torrent Ion AmpliSeq.

A qué grupo taxonómico pertenece una especie?

Desde hace ya tiempo hay más secuencias genómicas disponibles que las que podemos recordar y a menudo nos encontramos con nombres de organismos que no podemos ubicar, no sabemos si son bacterias aguas termales o artrópodos, por ejemplo. El siguiente programa puede ayudarnos precisamente a colocar dentro de la clasificación taxonómica vigente del NCBI un nombre de especie, o en general, cualquier taxón de nombre aceptado. Antes de ejecutarlo debes acceder al servidor FTP en ftp://ftp.ncbi.nih.gov/pub/taxonomy y descomprimir los archivos de nombres y nodos, como se explica en la cabecera del código Perl, haciendo apuntar la variable global $TAXONOMYPATH al directorio donde se encuentren. Una vez hechos estos ajustes el código ya está listo para usarse desde el terminal. Por ejemplo, si consultamos la taxonomía de Oryza sativa obtendremos esta respuesta, que podemos comparar con la figura, tomada de www.biomedcentral.com/1471-2164/8/283:

$ ./prog6.pl Oryza sativa 

# input taxon: Oryza sativa

# selected taxonID: 4530 \\ 
   URL: http://www.ncbi.nlm.nih.gov/Taxonomy/Browser/wwwtax.cgi?id=4530

# variants:
> Oryza sativa
> Oryza sativa L.

# lineage : Oryza sativa, Oryza, Oryzeae, Ehrhartoideae, BEP clade, Poaceae, 
Poales,commelinids, Liliopsida, Magnoliophyta, Spermatophyta, Euphyllophyta, 
Tracheophyta, Embryophyta, Streptophytina, Streptophyta, Viridiplantae, 
Eukaryota, cellular organisms

# rank : species, genus, tribe, subfamily, no_rank, family, order, subclass, 
class, no_rank, no_rank, no_rank, no_rank, no_rank, no_rank, phylum, kingdom, 
superkingdom, no_rank,

Éste es el código:

 #!/usr/bin/perl -w  
   
 # prog6  
 # programa que devuelve informacion taxonomica para un taxon de entrada,   
 # que se apoya en la version texto de la clasificacion Taxonomy del NCBI,   
 # que se pueden descargar de ftp://ftp.ncbi.nih.gov/pub/taxonomy , en   
 # particular el fichero taxdump.tar.gz, que debes descomprimir para obtener   
 # los dos ficheros que se utilizan aqui  
 # Bruno Contreras Moreira, Junio de 2010  
   
 use strict;  
 $|=1;  
   
 if(!$ARGV[0])  
 {   
    die "# usage: $0 <taxon name from superkingdom to species, such as:\n".  
    "       'Arabidopsis thaliana' or 'Viridiplantae' but not 'thaliana'>\n";   
 }  
   
 my $VERBOSE   = 0 ;  
 my $TAXONOMYPATH = '/path/taxonomy/'; # directorio de taxdump.tar.gz  
 my $NAMESFILE  = $TAXONOMYPATH . 'names.dmp';  
 my $NODESFILE  = $TAXONOMYPATH . 'nodes.dmp';  
 my $NCBIURL   = 'http://www.ncbi.nlm.nih.gov/Taxonomy/Browser/wwwtax.cgi?id=';  
   
 ###################################################################  
   
 my ($n_of_taxa,$taxonID,$taxon,$ID,$name,$rank,$parentID) = (0,'','');  
 my (@names,%node,@lineage,@sorted_lineage,%lineage_name);  
 my ($lineage_names,$lineage_ranks) = ('','');  
   
 ## 1) captura el nombre del taxon de entrada, como Arabidopsis thaliana, y  
 ## sustituye caracteres '_' por espacios si los hubiera   
 if(scalar(@ARGV) > 1){ @ARGV = @ARGV[0,1]; } # corta tercera palabra < especie  
 else{ @ARGV = split(/_/,$ARGV[0]); @ARGV = @ARGV[0,1]; }  
   
 $taxon = join(' ',@ARGV);  
 $taxon =~ s/^\s+//g; # elimina espacios iniciales y finales  
 $taxon =~ s/\s+$//g;   
   
 print "# input taxon: $taxon\n\n";  
   
 ## 2) busca el taxonID del taxon de entrada  
 open(NAMES,$NAMESFILE) || die "# $0 : cannot open $NAMESFILE\n";  
 while(<NAMES>)  
 {  
    next if(!/$taxon/i);  
      
    #3702   |   Arabidopsis thaliana   |      |   scientific name  
    if(/^(\d+)\s+\|\s+(.*?)\|/)  
    {  
       ($ID,$name) = ($1,$2);   
       $name =~ s/^\s+//g;   
       $name =~ s/\s+$//g;   
            
       # comprueba que el taxon buscado coincide con el principio de $name,   
       # evita aceptar cadenas que en realidad coinciden con la especie,   
       # que a veces se pueden encontrar en generos muy distintos  
       next if(index($name,$taxon) != 0);  
         
       # si el taxon buscado contiene una sola palabra evita  
       # aceptar cadenas de especies, que tendran dos palabras  
       next if($taxon !~ /\s+/ && $name =~ /\s+/);  
            
       if(!$n_of_taxa || $ID eq $taxonID) # guarda primer taxonID   
       {  
          $taxonID = $ID;  
          push(@names,$name);  
          $n_of_taxa++;  
               
          if($VERBOSE){ print }  
       }  
       else  
       {  
          if($VERBOSE)  
          {   
             # muestra otras posibles apariciones del taxon  
             print "# skip taxon: $ID\n";   
          }     
          else{ last } # termina la lectura del fichero   
       }     
    }        
 }  
 close(NAMES);  
   
 if(!$n_of_taxa){ die "# cannot find taxon $taxon in $NAMESFILE , exit\n"; }  
 else  
 {   
    print "# selected taxonID: $taxonID  URL: $NCBIURL$taxonID\n";  
    print "\n# variants:\n";   
    foreach $name (@names){ print "> $name\n"; }  
 }  
   
 ## 3) busca taxon padre del taxonID encontrado  
 open(NODES,$NODESFILE) || die "# $0 : cannot open $NODESFILE\n";  
 while(<NODES>)  
 {  
    #132596   |   79512   |   genus...  
    #tax_id         -- node id in GenBank taxonomy database  
     #parent tax_id      -- parent node id in GenBank taxonomy   
     #rank         -- rank of this node (superkingdom, kingdom, ...)   
    next if(/forma/ || /varietas/); # evita rangos < especie  
    if(/^$taxonID\t/)  
    {  
       my @data = split(/\t|\t/,$_);  
       $parentID = $data[2];  
       $rank   = $data[4];   
       if($VERBOSE){ print }  
       last;  
    }  
 }  
 close(NODES);   
   
 if(!$parentID){ die "\n# cannot find taxon '$taxon' in $NODESFILE , exit\n"; }  
   
 ## 4) lee arbol taxonomico del nivel de especie hacia arriba   
 ## (son en 2010 35MB, caben en cualquier RAM)  
 open(NODES,$NODESFILE) || die "# $0 : cannot open $NODESFILE\n";  
 while(<NODES>)  
 {  
    next if(/forma/ || /varietas/);  
    if(/^(\d+)\t\|\t(\d+)\t\|\t(\S+)/)  
    {  
       $node{$1}{'p'} = $2; # p = parent node  
       $node{$1}{'r'} = $3; # r = rank  
    }  
 }  
 close(NODES);   
   
 ## 5) reconstruye linaje de $taxonID en terminos de IDs  
 # 5.1) primero guarda datos de $taxonID  
 push(@lineage,$taxonID);  
 $lineage_name{$taxonID} = $rank;  
 $node{$taxonID}{'r'} = $rank;  
   
 # 5.2) ahora guarda los de los taxones superiores  
 while($parentID ne $taxonID && $parentID > 1)  
 {  
    push(@lineage,$parentID);  
    $parentID = $node{$parentID}{'p'};  
 }  
 @sorted_lineage = sort{$a<=>$b}(@lineage);  
 $taxon = shift(@sorted_lineage);   
   
 ## 6) recupera los nombres del linaje de $taxonID leyendo NAMES de nuevo,  
 ## que contiene los taxones ordenados de menor a mayor  
 open(NAMES,$NAMESFILE) || die "# $0 : cannot open $NAMESFILE\n";  
 while(<NAMES>)  
 {  
    next if(!/scientific name/);  
    if(/^(\d+)\s+\|\s+(.*?)\|/)  
    {  
       ($ID,$name) = ($1,$2);   
       next if($ID ne $taxon);  
         
       $name =~ s/^\s+//g;   
       $name =~ s/\s+$//g;   
       $lineage_name{$ID} = $name;  
       if(@sorted_lineage){ $taxon = shift(@sorted_lineage) }  
       else{ last } # termina si no quedan mas IDs  
    }        
 }  
 close(NAMES);  
   
 ## 7) enumera el linaje de $taxoID  
 foreach $ID (@lineage)  
 {  
    $rank = $node{$ID}{'r'};  
    if($rank eq 'no'){ $rank = 'no_rank' }  
      
    $lineage_names .= "$lineage_name{$ID}, ";  
    $lineage_ranks .= "$rank, ";  
 }  
   
 print "\n# lineage : $lineage_names\n# rank  : $lineage_ranks\n";