मैं एक सामान्यीकृत सामान्य वितरण ( विकिपीडिया प्रविष्टि ) का उपयोग करके संयंत्र फैलाव का मॉडलिंग कर रहा हूं , जिसमें संभावना घनत्व फ़ंक्शन है:
जहां दूरी की यात्रा है, स्केल पैरामीटर है, और आकार पैरामीटर है। इस वितरण के मानक विचलन द्वारा यात्रा की गई औसत दूरी दी गई है:
यह सुविधाजनक है क्योंकि यह एक घातीय आकृति के लिए अनुमति देता है जब , एक गाऊसी आकार जब , और जब एक लेप्टोक्यूरिक वितरण के लिए । यह वितरण नियमित रूप से पौधे के फैलाव वाले साहित्य में फसल देता है, भले ही यह सामान्य रूप से बहुत दुर्लभ है, और इसलिए इसके बारे में जानकारी प्राप्त करना मुश्किल है।
सबसे दिलचस्प पैरामीटर और माध्य फैलाव दूरी हैं।
मैं अनुमान लगाने के लिए कोशिश कर रहा हूँ और एमसीएमसी का उपयोग कर, लेकिन मैं नमूना प्रस्ताव मूल्यों के लिए एक कारगर तरीका के साथ आने के लिए संघर्ष कर रहा हूँ। अब तक, मैंने मेट्रोपोलिस-हेस्टिंग्स का उपयोग किया है, और वर्दी वितरण और से खींचा है , और मुझे लगभग 200-400 मीटर की दूरी पर मध्य दूरी मिलती है, जो जैविक अर्थ बनाती है। हालांकि, अभिसरण वास्तव में धीमा है, और मुझे विश्वास नहीं है कि यह पूर्ण पैरामीटर स्थान की खोज कर रहा है।
एक के लिए एक बेहतर प्रस्ताव वितरण के साथ आने के लिए इसकी मुश्किल और , क्योंकि वे एक दूसरे पर निर्भर करते हैं, अपने दम पर बहुत अर्थ के बिना। माध्य फैलाव दूरी का एक स्पष्ट जैविक अर्थ होता है, लेकिन एक दिया गया माध्य दूरी को असीम रूप से और कई संयोजनों द्वारा समझाया जा सकता है । जैसे और पीछे में सहसंबंध हैं।
अब तक मैंने मेट्रोपोलिस हेस्टिंग्स का उपयोग किया है, लेकिन मैं किसी भी अन्य एल्गोरिथ्म के लिए खुला हूं जो यहां काम करेगा।
प्रश्न: क्या कोई और लिए प्रस्ताव मूल्यों को आकर्षित करने के लिए अधिक कुशल तरीका सुझा सकता है ?
संपादित करें: सिस्टम के बारे में अतिरिक्त जानकारी: मैं घाटी में पौधों की आबादी का अध्ययन कर रहा हूं। उद्देश्य दाता पौधों और परागण पौधों के बीच पराग द्वारा यात्रा की गई दूरी के वितरण को निर्धारित करना है। मेरे पास जो डेटा हैं:
- हर संभव पराग दाता के लिए स्थान और डीएनए
- 60 मातृ पौधों (यानी पराग रिसीवर्स) के नमूने से एकत्र किए गए बीज जिन्हें उगाया और जीनोटाइप किया गया है।
- प्रत्येक मातृ पौधे के लिए स्थान और डीएनए।
मुझे दाता पौधों की पहचान नहीं पता है, लेकिन यह आनुवंशिक डेटा से यह पता लगाया जा सकता है कि कौन से दाता प्रत्येक अंकुर के पिता हैं। मान लें कि यह जानकारी प्रत्येक संतान दाता के लिए एक पंक्ति और प्रत्येक उम्मीदवार दाता के लिए एक कॉलम के साथ संभाव्यता जी के मैट्रिक्स में निहित है , जो प्रत्येक उम्मीदवार को केवल आनुवंशिक डेटा के आधार पर प्रत्येक संतान का पिता होने की संभावना देता है। जी को गणना करने में लगभग 3 सेकंड लगते हैं, और हर पुनरावृत्ति पर पुनर्गणना करने की आवश्यकता होती है, जो चीजों को काफी कम कर देता है।
चूँकि हम आम तौर पर नजदीकी उम्मीदवार दाताओं से अपेक्षा करते हैं कि वे पिता होने की अधिक संभावना रखते हैं, यदि आप संयुक्त रूप से पितृत्व और फैलाव का अनुमान लगाते हैं, तो पितृत्व आक्रमण अधिक सटीक है। मैट्रिक्स डी में जी के समान आयाम हैं , और इसमें केवल माता और उम्मीदवार के बीच की दूरी और मापदंडों के कुछ वेक्टर के आधार पर पितृत्व की संभावनाएं शामिल हैं। डी और जी में गुणन तत्व, आनुवंशिक और स्थानिक डेटा दिए गए पितृत्व की संयुक्त संभावना देता है। गुणक मानों का गुणन विखण्डन मॉडल की संभावना देता है।
जैसा कि ऊपर वर्णित है, मैं जीएनडी का उपयोग मॉडल के प्रसार के लिए कर रहा हूं। वास्तव में मैंने वास्तव में एक GND और एक समान वितरण का उपयोग किया था ताकि बहुत दूर के उम्मीदवारों की संभावना के लिए अनुमति देने के लिए पितृत्व की उच्च संभावना अकेले होने के कारण (आनुवंशिकी गड़बड़ है) जिसे अनदेखा किया गया तो GND की स्पष्ट पूंछ को फुलाया जाएगा। तो फैलाव दूरी की संभावना है:
जहाँ GND से फैलाव की संभावना है, N उम्मीदवारों की संख्या है, और ( ) यह निर्धारित करता है कि GND फैलाव में कितना योगदान देता है।
इसलिए दो अतिरिक्त विचार हैं जो कम्प्यूटेशनल बोझ को बढ़ाते हैं:
- अव्यवस्था दूरी ज्ञात नहीं है, लेकिन प्रत्येक पुनरावृत्ति पर अनुमान लगाया जाना चाहिए, और ऐसा करने के लिए जी बनाना महंगा है।
- एक तीसरा पैरामीटर है, , पर एकीकृत करने के लिए।
इन कारणों से मुझे ऐसा लग रहा था कि ग्रिड प्रक्षेप करने के लिए कभी-कभी इतना जटिल है, लेकिन मुझे अन्यथा आश्वस्त होने की खुशी है।
उदाहरण
यहां मेरे द्वारा उपयोग किए गए अजगर कोड का एक सरल उदाहरण है। मैंने आनुवांशिक डेटा से पितृत्व के आकलन को सरल बनाया है, क्योंकि इसमें बहुत सारे अतिरिक्त कोड शामिल होंगे, और इसे 0 और 1 के बीच मूल्यों के मैट्रिक्स के साथ बदल दिया जाएगा।
GND की गणना करने के लिए सबसे पहले, कार्यों को परिभाषित करें:
import numpy as np
from scipy.special import gamma
def generalised_normal_PDF(x, a, b, gamma_b=None):
"""
Calculate the PDF of the generalised normal distribution.
Parameters
----------
x: vector
Vector of deviates from the mean.
a: float
Scale parameter.
b: float
Shape parameter
gamma_b: float, optional
To speed up calculations, values for Euler's gamma for 1/b
can be calculated ahead of time and included as a vector.
"""
xv = np.copy(x)
if gamma_b:
return (b/(2 * a * gamma_b )) * np.exp(-(xv/a)**b)
else:
return (b/(2 * a * gamma(1.0/b) )) * np.exp(-(xv/a)**b)
def dispersal_GND(x, a, b, c):
"""
Calculate a probability that each candidate is a sire
assuming assuming he is either drawn at random form the
population, or from a generalised normal function of his
distance from each mother. The relative contribution of the
two distributions is controlled by mixture parameter c.
Parameters
----------
x: vector
Vector of deviates from the mean.
a: float
Scale parameter.
b: float
Shape parameter
c: float between 0 and 1.
The proportion of probability mass assigned to the
generalised normal function.
"""
prob_GND = generalised_normal_PDF(x, a, b)
prob_GND = prob_GND / prob_GND.sum(axis=1)[:, np.newaxis]
prob_drawn = (prob_GND * c) + ((1-c) / x.shape[1])
prob_drawn = np.log(prob_drawn)
return prob_drawn
अगले 2000 उम्मीदवारों, और 800 संतानों का अनुकरण करें। साथ ही संतान की माँ और उम्मीदवार के पिता और एक डमी के बीच की दूरी की सूची बनाएँ जी मैट्रिक्स के ।
n_candidates = 2000 # Number of candidates in the population
n_offspring = 800 # Number of offspring sampled.
# Create (log) matrix G.
# These are just random values between 0 and 1 as an example, but must be inferred in reality.
g_matrix = np.random.uniform(0,1, size=n_candidates*n_offspring)
g_matrix = g_matrix.reshape([n_offspring, n_candidates])
g_matrix = np.log(g_matrix)
# simulate distances to ecah candidate father
distances = np.random.uniform(0,1000, 2000)[np.newaxis]
प्रारंभिक पैरामीटर मान सेट करें:
# number of iterations to run
niter= 100
# set intitial values for a, b, and c.
a_current = np.random.uniform(0.001,500, 1)
b_current = np.random.uniform(0.01, 3, 1)
c_current = np.random.uniform(0.001, 1, 1)
# set initial likelihood to a very small number
lik_current = -10e12
बदले में, बी, और सी को अपडेट करें और मेट्रोपोलिस अनुपात की गणना करें।
# number of iterations to run
niter= 100
# set intitial values for a, b, and c.
# When values are very small, this can cause the Gamma function to break, so the limit is set to >0.
a_current = np.random.uniform(0.001,500, 1)
b_current = np.random.uniform(0.01, 3, 1)
c_current = np.random.uniform(0.001, 1, 1)
# set initial likelihood to a very small number
lik_current = -10e12
# empty array to store parameters
store_params = np.zeros([niter, 3])
for i in range(niter):
a_proposed = np.random.uniform(0.001,500, 1)
b_proposed = np.random.uniform(0.01,3, 1)
c_proposed = np.random.uniform(0.001,1, 1)
# Update likelihood with new value for a
prob_dispersal = dispersal_GND(distances, a=a_proposed, b=b_current, c=c_current)
lik_proposed = (g_matrix + prob_dispersal).sum() # lg likelihood of the proposed value
# Metropolis acceptance ration for a
accept = bool(np.random.binomial(1, np.min([1, np.exp(lik_proposed - lik_current)])))
if accept:
a_current = a_proposed
lik_current = lik_proposed
store_params[i,0] = a_current
# Update likelihood with new value for b
prob_dispersal = dispersal_GND(distances, a=a_current, b=b_proposed, c=c_current)
lik_proposed = (g_matrix + prob_dispersal).sum() # log likelihood of the proposed value
# Metropolis acceptance ratio for b
accept = bool(np.random.binomial(1, np.min([1, np.exp(lik_proposed - lik_current)])))
if accept:
b_current = b_proposed
lik_current = lik_proposed
store_params[i,1] = b_current
# Update likelihood with new value for c
prob_dispersal = dispersal_GND(distances, a=a_current, b=b_current, c=c_proposed)
lik_proposed = (g_matrix + prob_dispersal).sum() # lg likelihood of the proposed value
# Metropolis acceptance ratio for c
accept = bool(np.random.binomial(1, np.min([1, np.exp(lik_proposed - lik_current)])))
if accept:
c_current = c_proposed
lik_current = lik_proposed
store_params[i,2] = c_current