मैं N=400 न्यूरॉन्स से बने नेटवर्क की गतिशीलता को हल करने का प्रयास कर रहा हूं।

इसका मतलब है कि मेरे पास 400 युग्मित समीकरण हैं जो निम्नलिखित नियमों का पालन करते हैं:

मैं = 0,1,2...399
J(i,j) = i और j का कुछ फंक्शन (जहाँ j एक डमी वैरिएबल है)
I(i) = i
. का कुछ फलन dr(i,t)/dt = -r(i,t) + ० से ३९९ तक j पर योग [J(i,j)*r(j)] + I(i)

मैं कैसे हल करूं?

मुझे पता है कि 3 ऑड्स की प्रणाली के लिए। मैंने 3 odes और प्रारंभिक स्थितियों को परिभाषित किया और फिर odeint लागू किया। क्या इस मामले में प्रदर्शन करने का कोई बेहतर तरीका है?

अब तक मैंने निम्नलिखित कोड की कोशिश की (यह अच्छा नहीं है क्योंकि यह अनंत लूप में प्रवेश करता है):

N=400
t=np.linspace(0,20,1000)
J0=0.5
J1=2.5
I0=0.5
I1=0.001
i=np.arange(0,400,1)
theta=(2*np.pi)*i/N
I=I0+I1*cos(theta)
r=np.zeros(400)
x0 = [np.random.rand() for ii in i]

def threshold(y):
    if y>0:
        return y
    else:
        return 0

def vectors(x,t):
    for ii in i:
        r[ii]=x[ii]
    for ii in i:
        drdt[ii] = -r[ii] + threshold(I[ii]+sum(r[iii]*(J0+J1*cos(theta[ii]-theta[iii]))/N for iii in i))
    return drdt

x=odeint(vectors,x0,t)

1
enter_thevoid 5 मई 2019, 17:50

1 उत्तर

सबसे बढ़िया उत्तर

मुझे लगता है कि आपके कोड में स्पष्ट सुधार और परिवर्धन करने के बाद, मैं इसे चलाने में सक्षम था। यह वास्तव में अनंत लूप में नहीं था, यह बहुत धीमा था। आप जितना संभव हो सके अपनी गणनाओं को "सदिश" करके प्रदर्शन में काफी सुधार कर सकते हैं। यह लूप को पायथन के बजाय सी कोड में गणना करने की अनुमति देता है। एक संकेत है कि बहुत सुधार की गुंजाइश है sum over j from 0 to 399[J(i,j)*r(j)]। यह मैट्रिक्स J और सदिश r के गुणनफल को व्यक्त करने का एक और तरीका है। तो हमारे पास कोड में वास्तव में J @ r जैसा कुछ होना चाहिए, न कि उन सभी स्पष्ट पायथन लूप्स।

कुछ और बदलाव के बाद, यहां आपके कोड का एक संशोधित संस्करण है। यह मूल की तुलना में काफी तेज है। मैंने भी थोड़ा पुनर्गठित किया, और एक प्लॉट जोड़ा।

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt


def computeIJ(N):
    i = np.arange(N)
    theta = (2*np.pi)*i/N

    I0 = 0.5
    I1 = 0.001
    I = I0 + I1*np.cos(theta)

    J0 = 0.5
    J1 = 2.5
    delta_theta = np.subtract.outer(theta, theta)
    J = J0 + J1*np.cos(delta_theta)
    return I, J / N


def vectors2(r, t, I, J):
    s = J @ r
    drdt = -r + np.maximum(I + s, 0)
    return drdt


N = 400

I, J = computeIJ(N)

np.random.seed(123)
r0 = np.random.rand(N)
t = np.linspace(0, 20, 1000)

r = odeint(vectors2, r0, t, args=(I, J))

for i in [0, 100, 200, 300, 399]:
    plt.plot(t, r[:, i], label='i = %d' % i)

plt.xlabel('t')
plt.legend(shadow=True)
plt.grid()

plt.show()

यहाँ स्क्रिप्ट द्वारा उत्पन्न प्लॉट है:

plot

3
Warren Weckesser 5 मई 2019, 19:07