बायोपथॉन - अनुक्रम संरेखण

Sequence alignment उनके बीच समानता के क्षेत्र की पहचान करने के लिए एक विशिष्ट क्रम में दो या दो से अधिक दृश्यों (डीएनए, आरएनए या प्रोटीन अनुक्रमों) की व्यवस्था करने की प्रक्रिया है।

समान क्षेत्र की पहचान करने से हमें बहुत सी जानकारी का पता लगाने में मदद मिलती है जैसे कि प्रजातियों के बीच क्या लक्षण संरक्षित हैं, आनुवंशिक रूप से कितनी अलग प्रजातियां हैं, कैसे प्रजातियां विकसित होती हैं, आदि। बायोपथॉन अनुक्रम संरेखण के लिए व्यापक समर्थन प्रदान करता है।

आइए इस अध्याय में बायोपथॉन द्वारा प्रदान की गई कुछ महत्वपूर्ण विशेषताओं को जानें -

पार्सिंग अनुक्रम संरेखण

बायोपिथॉन अनुक्रम संरेखण को पढ़ने और लिखने के लिए एक मॉड्यूल, Bio.AlignIO प्रदान करता है। जैव सूचना विज्ञान में, पहले सीखे गए अनुक्रम डेटा के समान अनुक्रम संरेखण डेटा निर्दिष्ट करने के लिए बहुत सारे प्रारूप उपलब्ध हैं। Bio.AlignIO Bio.SeqIO के समान API प्रदान करता है सिवाय इसके कि Bio.SeqIO अनुक्रम डेटा पर काम करता है और Bio.AlignIO अनुक्रम संरेखण डेटा पर काम करता है।

सीखना शुरू करने से पहले, आइए हम इंटरनेट से एक नमूना अनुक्रम संरेखण फ़ाइल डाउनलोड करें।

नमूना फ़ाइल डाउनलोड करने के लिए, नीचे दिए गए चरणों का पालन करें -

Step 1 - अपना पसंदीदा ब्राउज़र खोलें और पर जाएं http://pfam.xfam.org/family/browseवेबसाइट। यह सभी Pfam परिवारों को वर्णमाला क्रम में दिखाएगा।

Step 2- बीज मूल्य के कम संख्या वाले किसी एक परिवार को चुनें। इसमें न्यूनतम डेटा शामिल है और हमें संरेखण के साथ आसानी से काम करने में सक्षम बनाता है। यहां, हमने PF18225 का चयन / क्लिक किया है और यह खुल जाता हैhttp://pfam.xfam.org/family/PF18225 और अनुक्रम संरेखण सहित इसके बारे में पूरा विवरण दिखाता है।

Step 3 - संरेखण अनुभाग पर जाएं और स्टॉकहोम प्रारूप (PF18225_seed.txt) में अनुक्रम संरेखण फ़ाइल डाउनलोड करें।

आइए नीचे दिए गए Bio.AlignIO का उपयोग करके डाउनलोड किए गए अनुक्रम संरेखण फ़ाइल को पढ़ने का प्रयास करें -

आयात Bio.AlignIO मॉड्यूल

>>> from Bio import AlignIO

रीड मेथड का उपयोग कर अलाइनमेंट पढ़ें। रीड मेथड का उपयोग किसी दिए गए फ़ाइल में उपलब्ध एकल संरेखण डेटा को पढ़ने के लिए किया जाता है। यदि दी गई फ़ाइल में कई संरेखण शामिल हैं, तो हम पार्स विधि का उपयोग कर सकते हैं। पार्स विधि Bio.SeqIO मॉड्यूल में पार्स विधि के समान चलने योग्य संरेखण वस्तु देता है।

>>> alignment = AlignIO.read(open("PF18225_seed.txt"), "stockholm")

संरेखण वस्तु प्रिंट करें।

>>> print(alignment)
SingleLetterAlphabet() alignment with 6 rows and 65 columns
MQNTPAERLPAIIEKAKSKHDINVWLLDRQGRDLLEQRVPAKVA...EGP B7RZ31_9GAMM/59-123 
AKQRGIAGLEEWLHRLDHSEAIPIFLIDEAGKDLLEREVPADIT...KKP A0A0C3NPG9_9PROT/58-119 
ARRHGQEYFQQWLERQPKKVKEQVFAVDQFGRELLGRPLPEDMA...KKP A0A143HL37_9GAMM/57-121 
TRRHGPESFRFWLERQPVEARDRIYAIDRSGAEILDRPIPRGMA...NKP A0A0X3UC67_9GAMM/57-121 
AINRNTQQLTQDLRAMPNWSLRFVYIVDRNNQDLLKRPLPPGIM...NRK B3PFT7_CELJU/62-126 
AVNATEREFTERIRTLPHWARRNVFVLDSQGFEIFDRELPSPVA...NRT K4KEM7_SIMAS/61-125
>>>

हम संरेखण (SeqRecord) को संरेखण में और साथ ही नीचे भी देख सकते हैं -

>>> for align in alignment: 
... print(align.seq) 
... 
MQNTPAERLPAIIEKAKSKHDINVWLLDRQGRDLLEQRVPAKVATVANQLRGRKRRAFARHREGP 
AKQRGIAGLEEWLHRLDHSEAIPIFLIDEAGKDLLEREVPADITA---RLDRRREHGEHGVRKKP 
ARRHGQEYFQQWLERQPKKVKEQVFAVDQFGRELLGRPLPEDMAPMLIALNYRNRESHAQVDKKP 
TRRHGPESFRFWLERQPVEARDRIYAIDRSGAEILDRPIPRGMAPLFKVLSFRNREDQGLVNNKP 
AINRNTQQLTQDLRAMPNWSLRFVYIVDRNNQDLLKRPLPPGIMVLAPRLTAKHPYDKVQDRNRK 
AVNATEREFTERIRTLPHWARRNVFVLDSQGFEIFDRELPSPVADLMRKLDLDRPFKKLERKNRT 
>>>

एकाधिक संरेखण

सामान्य तौर पर, अधिकांश अनुक्रम संरेखण फ़ाइलों में एकल संरेखण डेटा होता है और यह उपयोग करने के लिए पर्याप्त है readइसे पार्स करने की विधि। एकाधिक अनुक्रम संरेखण अवधारणा में, दो या दो से अधिक अनुक्रमों की तुलना उनके बीच के सर्वश्रेष्ठ परिणाम मिलानों के लिए की जाती है और परिणाम एक ही फ़ाइल में कई अनुक्रम संरेखण में होते हैं।

यदि इनपुट अनुक्रम संरेखण प्रारूप में एक से अधिक अनुक्रम संरेखण शामिल हैं, तो हमें उपयोग करने की आवश्यकता है parse के बजाय विधि read नीचे बताए अनुसार विधि -

>>> from Bio import AlignIO 
>>> alignments = AlignIO.parse(open("PF18225_seed.txt"), "stockholm") 
>>> print(alignments) 
<generator object parse at 0x000001CD1C7E0360> 
>>> for alignment in alignments: 
... print(alignment) 
... 
SingleLetterAlphabet() alignment with 6 rows and 65 columns 
MQNTPAERLPAIIEKAKSKHDINVWLLDRQGRDLLEQRVPAKVA...EGP B7RZ31_9GAMM/59-123 
AKQRGIAGLEEWLHRLDHSEAIPIFLIDEAGKDLLEREVPADIT...KKP A0A0C3NPG9_9PROT/58-119 
ARRHGQEYFQQWLERQPKKVKEQVFAVDQFGRELLGRPLPEDMA...KKP A0A143HL37_9GAMM/57-121 
TRRHGPESFRFWLERQPVEARDRIYAIDRSGAEILDRPIPRGMA...NKP A0A0X3UC67_9GAMM/57-121 
AINRNTQQLTQDLRAMPNWSLRFVYIVDRNNQDLLKRPLPPGIM...NRK B3PFT7_CELJU/62-126 
AVNATEREFTERIRTLPHWARRNVFVLDSQGFEIFDRELPSPVA...NRT K4KEM7_SIMAS/61-125
>>>

यहाँ, पार्स विधि पुनरावृत्ति संरेखण वस्तु देता है और इसे वास्तविक संरेखण प्राप्त करने के लिए पुनरावृत्त किया जा सकता है।

पेयरवाइज सीक्वेंस एलाइनमेंट

Pairwise sequence alignment एक समय में केवल दो अनुक्रमों की तुलना करता है और सर्वोत्तम संभव अनुक्रम संरेखण प्रदान करता है। Pairwise समझने में आसान है और परिणामस्वरूप अनुक्रम संरेखण से अनुमान लगाने के लिए असाधारण है।

बायोपथॉन एक विशेष मॉड्यूल प्रदान करता है, Bio.pairwise2युग्मक विधि का उपयोग करके संरेखण अनुक्रम की पहचान करना। बायोपथॉन संरेखण अनुक्रम को खोजने के लिए सबसे अच्छा एल्गोरिथ्म लागू करता है और यह अन्य सॉफ़्टवेयर के बराबर है।

आइए हम युग्म के मॉड्यूल का उपयोग करते हुए दो सरल और काल्पनिक अनुक्रमों के अनुक्रम संरेखण को खोजने के लिए एक उदाहरण लिखते हैं। इससे हमें अनुक्रम संरेखण की अवधारणा को समझने में मदद मिलेगी और बायोप्थॉन का उपयोग करके इसे कैसे प्रोग्राम किया जा सकता है।

चरण 1

मॉड्यूल आयात करें pairwise2 नीचे दिए गए आदेश के साथ -

>>> from Bio import pairwise2

चरण 2

दो क्रम बनाएँ, seq1 और seq2 -

>>> from Bio.Seq import Seq 
>>> seq1 = Seq("ACCGGT") 
>>> seq2 = Seq("ACGT")

चरण 3

नीचे दिए गए कोड का उपयोग करके संरेखण को खोजने के लिए seq1 और seq2 के साथ युग्म विधि 2 .align.globalxx कॉल करें -

>>> alignments = pairwise2.align.globalxx(seq1, seq2)

यहाँ, globalxxविधि वास्तविक कार्य करती है और दिए गए अनुक्रमों में सभी सर्वोत्तम संभव संरेखण पाती है। दरअसल, Bio.pairwise2 विभिन्न तरीकों का एक सेट प्रदान करता है जो विभिन्न परिदृश्यों में संरेखण खोजने के लिए नीचे के सम्मेलन का अनुसरण करता है।

<sequence alignment type>XY

यहां, अनुक्रम संरेखण प्रकार संरेखण प्रकार को संदर्भित करता है जो वैश्विक या स्थानीय हो सकता है । वैश्विक प्रकार पूरे अनुक्रम को ध्यान में रखकर अनुक्रम संरेखण का पता लगा रहा है। स्थानीय प्रकार दिए गए अनुक्रमों के सबसेट को देख कर अनुक्रम संरेखण ढूंढ रहा है। यह थकाऊ होगा लेकिन दिए गए अनुक्रमों के बीच समानता के बारे में बेहतर विचार प्रदान करता है।

X मिलान अंक को संदर्भित करता है। संभावित मान x (सटीक मिलान), m (समान वर्णों के आधार पर स्कोर), d (उपयोगकर्ता वर्ण और मिलान स्कोर के साथ शब्दकोश प्रदान किया गया है) और अंत में c (कस्टम स्कोरिंग एल्गोरिदम प्रदान करने के लिए उपयोगकर्ता परिभाषित फ़ंक्शन)।
Y का अर्थ गैप पेनल्टी है। संभावित मान x (नो गैप पेनल्टी) हैं, एस (दोनों अनुक्रमों के लिए एक ही पेनल्टी), डी (प्रत्येक अनुक्रम के लिए अलग-अलग दंड) और अंत में सी (कस्टम डिफॉल्ट पेनाल्टी प्रदान करने के लिए उपयोगकर्ता परिभाषित फ़ंक्शन)

तो, स्थानीयकरण भी एक मान्य विधि है, जो स्थानीय संरेखण तकनीक का उपयोग करके अनुक्रम संरेखण का पता लगाता है, उपयोगकर्ता मैचों के लिए शब्दकोश प्रदान करता है और उपयोगकर्ता दोनों अनुक्रमों के लिए अंतर दंड प्रदान करता है।

>>> test_alignments = pairwise2.align.localds(seq1, seq2, blosum62, -10, -1)

इधर, blosum62 एक मेल को संदर्भित करता है जो युग्म स्कोर 2 मॉड्यूल में मैच स्कोर प्रदान करने के लिए उपलब्ध है। -10 अंतर दंड को संदर्भित करता है और -1 अंतर अंतराल दंड को संदर्भित करता है।

चरण 4

चलने योग्य संरेखण ऑब्जेक्ट पर लूप करें और प्रत्येक व्यक्तिगत संरेखण ऑब्जेक्ट प्राप्त करें और इसे प्रिंट करें।

>>> for alignment in alignments: 
... print(alignment) 
... 
('ACCGGT', 'A-C-GT', 4.0, 0, 6) 
('ACCGGT', 'AC--GT', 4.0, 0, 6) 
('ACCGGT', 'A-CG-T', 4.0, 0, 6) 
('ACCGGT', 'AC-G-T', 4.0, 0, 6)

चरण 5

Bio.pairwise2 मॉड्यूल बेहतर परिणाम देखने के लिए एक स्वरूपण विधि, format_alignment प्रदान करता है -

>>> from Bio.pairwise2 import format_alignment 
>>> alignments = pairwise2.align.globalxx(seq1, seq2) 
>>> for alignment in alignments: 
... print(format_alignment(*alignment)) 
...

ACCGGT 
| | || 
A-C-GT 
   Score=4 
   
ACCGGT 
|| || 
AC--GT 
   Score=4 

ACCGGT 
| || | 
A-CG-T 
   Score=4 

ACCGGT 
|| | | 
AC-G-T 
   Score=4

>>>

बायोपथॉन अनुक्रम संरेखण, संरेखित करने के लिए एक और मॉड्यूल भी प्रदान करता है। यह मॉड्यूल बस एल्गोरिदम, पैरामीटर, मैच स्कोर, गैप पेनल्टी आदि जैसे पैरामीटर की सेटिंग के लिए एपीआई का एक अलग सेट प्रदान करता है, संरेखित वस्तु में एक साधारण रूप निम्नानुसार है -

>>> from Bio import Align
>>> aligner = Align.PairwiseAligner()
>>> print(aligner)
Pairwise sequence aligner with parameters
   match score: 1.000000
   mismatch score: 0.000000
   target open gap score: 0.000000
   target extend gap score: 0.000000
   target left open gap score: 0.000000
   target left extend gap score: 0.000000
   target right open gap score: 0.000000
   target right extend gap score: 0.000000
   query open gap score: 0.000000
   query extend gap score: 0.000000
   query left open gap score: 0.000000
   query left extend gap score: 0.000000
   query right open gap score: 0.000000
   query right extend gap score: 0.000000
   mode: global
>>>

अनुक्रम संरेखण उपकरण के लिए समर्थन

बायोपथॉन Bio.Align.Applications मॉड्यूल के माध्यम से बहुत सारे अनुक्रम संरेखण उपकरण को इंटरफ़ेस प्रदान करता है। कुछ उपकरण नीचे सूचीबद्ध हैं -

ClustalW
MUSCLE
EMBOSS सुई और पानी

आइए सबसे लोकप्रिय संरेखण उपकरण, ClustalW के माध्यम से अनुक्रम संरेखण बनाने के लिए Biopython में एक सरल उदाहरण लिखते हैं।

Step 1 - से Clustalw प्रोग्राम डाउनलोड करें http://www.clustal.org/download/current/और इसे स्थापित करें। इसके अलावा, सिस्टम पथ को "क्लस्टर" इंस्टॉलेशन पथ के साथ अपडेट करें।

Step 2 - मॉड्यूल Bio.Align.Applications से ClustalwCommanLine आयात करें।

>>> from Bio.Align.Applications import ClustalwCommandline

Step 3 - इनपुट फाइल के साथ ClustalwCommanLine पर कॉल करके cmd सेट करें, Biopython पैकेज में उपलब्ध opuntia.fasta। https://raw.githubusercontent.com/biopython/biopython/master/Doc/examples/opuntia.fasta

>>> cmd = ClustalwCommandline("clustalw2",
infile="/path/to/biopython/sample/opuntia.fasta")
>>> print(cmd)
clustalw2 -infile=fasta/opuntia.fasta

Step 4 - कॉलिंग सीएमडी () क्लॉस्टल कमांड को चलाएगा और परिणामी संरेखण फ़ाइल, ओपंटिया .aln का आउटपुट देगा।

>>> stdout, stderr = cmd()

Step 5 - नीचे संरेखण फ़ाइल को पढ़ें और प्रिंट करें -

>>> from Bio import AlignIO
>>> align = AlignIO.read("/path/to/biopython/sample/opuntia.aln", "clustal")
>>> print(align)
SingleLetterAlphabet() alignment with 7 rows and 906 columns
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273285|gb|AF191659.1|AF191
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273284|gb|AF191658.1|AF191
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273287|gb|AF191661.1|AF191
TATACATAAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273286|gb|AF191660.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273290|gb|AF191664.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273289|gb|AF191663.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273291|gb|AF191665.1|AF191
>>>