अराजकता खेल अनुक्रम

Question

मैं डीएनए अनुक्रम इस पते में तैनात के लिए अराजकता खेल बनाने के लिए mathematica कोड की कोशिश की है: http://facstaff.unca.edu/mcmcclur/blog/GeneCGR.html

इस तरह है जो:

genome = Import["c:\data\sequence.fasta", "Sequence"]; 
genome = StringReplace[ToString[genome], {"{" -> "", "}" -> ""}]; 
chars = StringCases[genome, "G" | "C" | "T" | "A"]; 
f[x_, "A"] := x/2; 
f[x_, "T"] := x/2 + {1/2, 0}; 
f[x_, "G"] := x/2 + {1/2, 1/2}; 
f[x_, "C"] := x/2 + {0, 1/2}; 
pts = FoldList[f, {0.5, 0.5}, chars]; 
Graphics[{PointSize[Tiny], Point[pts]}] 

fasta अनुक्रम है कि मैं

: सिर्फ AACCTTTGATCAAA और ग्राफ उत्पन्न करने की तरह अक्षरों का एक क्रम है इस तरह की बात आती है

कोड छोटे अनुक्रमों के साथ ठीक काम करता है, लेकिन जब मैं एक विशाल अनुक्रम रखना चाहता हूं, उदाहरण के लिए क्रोमोसोम के लगभग 40 एमबी, कार्यक्रम में बहुत समय लगता है और केवल एक काला वर्ग प्रदर्शित करता है ताकि विश्लेषण करना असंभव हो। क्या उपरोक्त कोड को बेहतर बनाना संभव है, ताकि जिस वर्ग में इसे प्रदर्शित किया जाएगा, वह बड़ा होगा ?, जिस तरह से वर्ग केवल वर्ग इकाई होना चाहिए। अग्रिम में आपकी मदद के लिए धन्यवाद नीचे वृद्धिशील संपादन के

Answer 1

सारांश:

यह आपको बिंदु कंप्यूटिंग में काफी speedup दे देंगे संकलित कोड का उपयोग करके निर्देशांक (50x छोड़कर कंप्यूटिंग shifts):

shifts = chars /. {"A" -> {0., 0.}, "T" -> {.5, 0.}, "G" -> {.5, .5}, "C" -> {0, .5}}; 
fun1d = Compile[{{a, _Real, 1}}, FoldList[#/2 + #2 &, .5, a], CompilationTarget -> "C"] 
pts = Transpose[fun1d /@ Transpose[shifts]]; 

आपके कोड में बाधा वास्तव में ग्राफिक को प्रतिपादित कर रही है, हम प्रत्येक बिंदु को साजिश करने के बजाय, हम बिंदुओं की घनत्व को कल्पना करेंगे:

threshold = 1; 
With[{size = 300}, 
Image[1 - UnitStep[BinCounts[pts, 1/size, 1/size] - threshold]] 
] 

यदि कम से कम threshold अंक हैं तो एक क्षेत्र रंगीन काला होगा। size छवि-आयाम है। या तो बड़े आकार या बड़े थ्रेसहोल्ड को चुनकर आप "ब्लैक स्क्वायर समस्या" से बच सकते हैं।

---

अधिक विवरण के साथ मेरी मूल जवाब:

मेरी नहीं बल्कि दिनांकित मशीन पर, कोड बहुत धीमी गति से नहीं है।

chars = RandomChoice[{"A", "T", "C", "G"}, 800000]; 

f[x_, "A"] := x/2; 
f[x_, "T"] := x/2 + {1/2, 0}; 
f[x_, "G"] := x/2 + {1/2, 1/2}; 
f[x_, "C"] := x/2 + {0, 1/2}; 
Timing[pts = FoldList[f, {0.5, 0.5}, chars];] 
Graphics[{PointSize[Tiny], Point[pts]}] 

मैं 6.8 सेकंड की समय है, जो उपयोगी है जब तक आप इसे एक पाश में समय की बहुत सारी चलाने के लिए (अगर यह काफी तेजी से आपके उपयोग के मामले और मशीन के लिए नहीं है की आवश्यकता हो, कोई टिप्पणी जोड़ने करें, और हम इसे तेज करने की कोशिश करेंगे)।

दुर्भाग्यवश ग्राफिक को प्रस्तुत करना इस (36 सेकंड) से अधिक लंबा लेता है, और मुझे नहीं पता कि इसके बारे में आप कुछ भी कर सकते हैं या नहीं। एंटीअलाइजिंग को अक्षम करना आपके प्लेटफ़ॉर्म के आधार पर थोड़ा सा मदद कर सकता है, लेकिन अधिक नहीं: Style[Graphics[{PointSize[Tiny], Point[pts]}], Antialiasing -> False] (मेरे लिए यह नहीं है)। हम में से कई लोगों के लिए यह एक लंबे समय से परेशान है।

पूरे ग्राफिक होने के बारे में काला, आप इसे अपने माउस का उपयोग करके आकार बदल सकते हैं और इसे बड़ा बना सकते हैं। अगली बार जब आप अपनी अभिव्यक्ति का मूल्यांकन करेंगे, आउटपुट ग्राफ़िक इसके आकार को याद रखेगा। या ImageSize -> 800 को Graphics विकल्प के रूप में उपयोग करें। स्क्रीन के पिक्सेल घनत्व को ध्यान में रखते हुए एकमात्र अन्य समाधान जिसे मैं सोच सकता हूं (जिसमें ग्राफिक का आकार शामिल नहीं है) ग्रे के रंगों का उपयोग करके पिक्सेल घनत्व का प्रतिनिधित्व करना होगा, और घनत्व प्लॉट करना होगा।

संपादित करें: संकल्प के साथ

With[{resolution = 0.01}, 
ArrayPlot@BinCounts[pts, resolution, resolution] 
] 

खेल:

इस तरह आप घनत्व प्लॉट कर सकते हैं (इस भी गणना और बिंदु साजिश से प्रस्तुत करने के लिए बहुत बहुत तेजी से है) साजिश को अच्छा बनाने के लिए।

मेरे यादृच्छिक अनुक्रम उदाहरण के लिए, यह केवल एक ग्रे प्लॉट देता है। आपके जीनोम डेटा के लिए यह शायद एक और दिलचस्प पैटर्न देगा।

संपादित करें 2:

सबसे पहले, (पाली वैक्टर के आधार पर पात्रों की जगह, एक डाटासेट के लिए केवल एक बार किया जाना है तो:

यहाँ संकलन का उपयोग कर समारोह तेजी लाने के लिए एक आसान तरीका है आप परिणाम को बचा सकता है):

arr = chars /. {"A" -> {0., 0.}, "T" -> {.5, 0.}, "G" -> {.5, .5}, "C" -> {0, .5}}; 

तो चलो हमारे समारोह संकलन करते हैं:

fun = Compile[{{a, _Real, 2}}, FoldList[#/2 + #2 &, {.5, .5}, a], 
CompilationTarget -> "C"] 

CompilationTarget हटाएं यदि गणित का आपका संस्करण 8 से पहले है या आपके पास सी कंपाइलर स्थापित नहीं है।

fun[arr]; // Timing 

मुझे 0.6 सेकंड देता है, जो एक त्वरित 10x गति है।

संपादित करें 3:

एक और ~ 5x speedup संकलित समारोह (मैं CompilePrint का उपयोग कर इस संस्करण के साथ आने के लिए संकलन उत्पादन जाँच में कुछ गिरी कॉलबैक से बचने के ऊपर संकलित संस्करण की तुलना में संभव है - - अन्यथा यह स्पष्ट क्यों नहीं है यह तेजी से है):

fun1d = Compile[{{a, _Real, 1}}, FoldList[#/2 + #2 &, .5, a], 
    CompilationTarget -> "C"] 

arrt = Transpose[arr]; 
Timing[result = fun1d /@ arrt;] 
pts = Transpose[result]; 

यह मेरा मशीन पर 0.11 सेकंड में चलता है। एक और आधुनिक मशीन पर इसे 40 एमबी डेटासेट के लिए भी कुछ सेकंड में पूरा करना चाहिए।

मैंने अलग-अलग इनपुट में ट्रांसपोज़िशन को विभाजित कर दिया क्योंकि इस बिंदु पर fun1d का चलने का समय Transpose के चल रहे समय के साथ तुलनीय होना शुरू हो जाता है।