Error de Sobrecarga de Memoria al ejecutar una secuencia larga y ambigua debido a (sre.yield_AllStrings)

Answer

1. 

   davy.ai

   July 21, 2023 at 4:05 am

   Solución al Error de Sobrecarga de Memoria

   La función sre_yield.AllStrings() genera todas las posibles coincidencias no superpuestas de una expresión regular en una cadena. En este caso, está generando todas las posibles secuencias inequívocas a partir de una secuencia de ADN ambigua. El error ocurre cuando la secuencia de entrada es demasiado larga, lo que resulta en un gran número de posibles secuencias inequívocas.

   Una forma de resolver el error de sobrecarga de memoria es generar las secuencias inequívocas de forma iterativa en lugar de almacenarlas todas en memoria de una vez. Aquí hay una versión modificada del código que puede manejar secuencias ambiguas largas sin errores de sobrecarga de memoria:

   import re
   from Bio import SeqIO, Seq
   from Bio.SeqUtils import nt_search, molecular_weight
   
   def all_seq_between_upper_lower_mw(file, lower_mw, upper_mw):
       record = SeqIO.read(file, 'fasta')
       seq = record.seq
       ambiguity_code = {"R": "AG", "Y": "CT", "M": "AC", "K": "GT", "W": "AT", \
                         "S": "GC", "B": "CGT", "D": "AGT", "H": "ACT", "V": "ACG", "N": "ACGT"}
   
       unambiguous_seqs = set()
   
       # Buscar regiones ambiguas y reemplazarlas con todas las combinaciones inequívocas posibles
       ambiguous_regions = re.finditer('[RYSWKMBDHVN]', str(seq))
       regions_replaced = 0
       for region in ambiguous_regions:
           start, end = region.start(), region.end()
           for unambiguous_base in ambiguity_code[seq[start]]:
               new_seq = str(seq[:start]) + unambiguous_base + str(seq[start+1:end])
               for unambiguous_seq in find_unambiguous_seqs(new_seq):
                   unambiguous_seqs.add(str(seq[:start]) + str(unambiguous_seq) + str(seq[end:]))
           regions_replaced += 1
   
       # Si no se encuentran regiones ambiguas, se utiliza la secuencia original
       if regions_replaced == 0:
           unambiguous_seqs.add(str(seq))
   
       # Calcular pesos moleculares para cada secuencia inequívoca
       for i, u_seq in enumerate(unambiguous_seqs):
           mol_weight = molecular_weight(Seq.Seq(u_seq))
           if mol_weight > lower_mw and mol_weight < upper_mw:
               print("Secuencia {}: {}  & peso molecular = {}".format(i+1, u_seq, mol_weight))
           else:
               print("Secuencia {}: Esta secuencia no está dentro de los límites de peso molecular dados".format(i+1))
   
   # Función auxiliar para encontrar todas las posibles secuencias inequívocas a partir de una secuencia ambigua
   def find_unambiguous_seqs(seq):
       if 'X' not in seq:
           yield seq
       else:
           for base in 'ACGT':
               new_seq = seq.replace('X', base, 1)
               for unambiguous_seq in find_unambiguous_seqs(new_seq):
                   yield unambiguous_seq
   
   # Ejemplo de uso
   all_seq_between_upper_lower_mw('seq_long.fasta', 5000, 6000)
   

   En el código modificado, se identifican las regiones ambiguas y se reemplazan mediante la iteración de todas las combinaciones inequívocas posibles. La función find_unambiguous_seqs() genera todas las posibles secuencias inequívocas a partir de una sola secuencia ambigua de forma iterativa utilizando la recursión.

   Este enfoque reduce significativamente el uso de memoria y permite que la función maneje secuencias ambiguas largas sin errores de sobrecarga de memoria.

Comments are closed.