हैकेल में fmap के साथ फ़ंक्शन का उपयोग करके यादृच्छिक जनरेटर का उपयोग कैसे करें?

Question

मैं विकासवादी तंत्रिका नेटवर्क के साथ शोध कर रहा हूं, और एचएनएन का उपयोग कर रहा हूं। मेरा पहला सवाल यह है कि अगर पहले से ही हास्केल में कोई विकासवादी एल्गोरिदम फ्रेमवर्क मौजूद है, क्योंकि मैं कोई भी नहीं ढूंढ पा रहा था?

मैं वर्तमान में तंत्रिका नेटवर्क के वजन को सामान्य तरीके से बदलने के लिए एक रास्ता खोजने के लिए संघर्ष कर रहा हूं। फिलहाल, मैं वजन के HMatrix पर एक यादृच्छिक फ़ंक्शन (फॉर्म (RandomGen g) => g -> a -> (b,g) का मानचित्र) मैप करने का प्रयास कर रहा हूं।

यदि यह किया जा सकता है तो यादृच्छिक फ़ंक्शन का उपयोग करने के लिए मुझे मौजूदा fmap (या fold?) को संशोधित करने का एक सामान्य तरीका चाहिए। उदाहरण के लिए, मेरे पास ऐसा फ़ंक्शन हो सकता है जो उसके इनपुट में कुछ गॉसियन शोर जोड़ सकता है या नहीं, और यह पूरे नेटवर्क पर लागू होना चाहता है। मेरी समस्या यह है कि यादृच्छिक संख्या जनरेटर के साथ कैसे काम करना है।

नक्शा के लिए, मैं वर्तमान में कर रहा हूँ निम्नलिखित:

rmap :: (StdGen -> a -> (b,StdGen)) -> StdGen -> [a] -> ([b],StdGen) 
rmap _ g [] = ([],g) 
rmap f g (x:xs) = let (mapped, g') = rmap f g xs 
         (rVal, g'') = f g' x 
        in (rVal:mapped, g'') 

यह मेरे लिए एक हैक की तरह लगता है, और मैं बेहतर haskellers से कुछ उम्मीद कर रही थी कि कैसे इस अनियमितता अधिक से निपटने के लिए पर कुछ सलाह हो सकता है प्रभावी रूप से?

Answer 1

यह Traversable कक्षा के लिए है। mapAccumL (इसके बैक-टू-फ्रंट ट्विन mapAccumR के साथ) एक उच्च-ऑर्डर फ़ंक्शन है जो एक सामान्यीकृत फोल्ड-एंड-मैप ऑपरेशन को कैप्चर करता है, जो एक ट्रैवर्सबल स्ट्रक्चर में काम कर रहा है और तत्वों को बदल रहा है। ,

mapAccumL :: Traversable t => (a  -> b -> (a, c))  -> a  -> t b -> (a, t c) 
rmap  ::     (StdGen -> a -> (b, StdGen)) -> StdGen -> [a] -> ([b], StdGen) 

हम t ~ [] और a ~ StdGen सेट कर सकते हैं ताकि rmap मूल रूप से एक और नाम है: जैसा कि आप देख सकते हैं mapAccumL के प्रकार अपने कार्य के प्रकार के काफी करीब से मेल खाता - अपने यादृच्छिक मानचित्रण समारोह इस पद्धति का एक उदाहरण है mapAccumL के लिए, कुछ tuple-flipping के बाद।

rmap f z = swap . mapAccumL (\x y -> swap (f x y)) z 

Answer 2

मैं इस समस्या के तंत्रिका नेटवर्क पक्ष के बारे में कुछ भी नहीं कह सकता (मुझे उम्मीद है कि कोई इसके बारे में कुछ पोस्ट करेगा)। एक सामान्य हास्केलर के परिप्रेक्ष्य से, ऐसा लगता है कि आपको किसी प्रकार के यादृच्छिक मोनैड के अंदर अपनी गणना करना चाहिए। उदाहरण के लिए, MonadRandom।

फिर, अपने rmap के हस्ताक्षर की तरह कुछ में बदल जाता है:

rmap :: MonadRandom m => (a -> m b) -> [a] -> m [b] 

बस उस हस्ताक्षर को देखकर, आप महसूस कर सकते कि rmap भेष में traverse है।

यहाँ पहचान करने के लिए कुंजी पैटर्न है कि चीजें हैं जो StdGen -> a -> (b,StdGen) की तरह लग रही है (जो भी IO हो सकता है) एक यादृच्छिक इकाई के लिए a -> m b में तब्दील किया जा सकता है। एक बार जब आप इसे देखते हैं, तो आप हास्केल की मोनैड यूटिलिटीज की पूरी शक्ति का उपयोग शुरू कर सकते हैं।