Поиск самосогласованного решения уравнения

Question

В основе этого вопроса лежит набор функций, транскрибируемых из опубликованной модели нейронной сети. Когда я называю R, я получаю следующее сообщение об ошибке:

RuntimeError: maximum recursion depth exceeded while calling a Python object

Обратите внимание, что в каждом вызове R, рекурсивный вызов R производится для каждого другого нейрона в сети. Это и приводит к превышению глубины рекурсии. Каждое возвращаемое значение для R зависит от всех остальных (с сетью, содержащей N = 512 общих значений.) Кто-нибудь знает, какой метод следует использовать для вычисления самосогласованного решения для R? Обратите внимание, что R сам по себе является гладкой функцией. Я пробовал рассматривать это как проблему решения root-решения, но в этом случае размеры 512 не являются независимыми. При стольких степенях свободы корни никогда не обнаруживаются (используя функции scipy.optimize). Есть ли у Python какие-либо инструменты, которые могут помочь в этом? Может быть, было бы более естественно решить R, используя что-то вроде Mathematica? Я не знаю, как это обычно делается.

"""Recurrent model with strong excitatory recurrence.""" 


import numpy as np 


l = 3.14 


def R(x_i): 

    """Steady-state firing rate of neuron at location x_i. 

    Parameters 
    ---------- 
    x_i : number 
     Location of this neuron. 

    Returns 
    ------- 
    rate : float 
     Firing rate. 

    """ 

    N = 512 
    T = 1 

    x = np.linspace(-2, 2, N) 
    sum_term = 0 
    for x_j in x: 
     sum_term += J(x_i - x_j) * R(x_j) 

    rate = I_S(x_i) + I_A(x_i) + 1.0/N * sum_term - T 

    if rate < 0: 
     return 0 

    return rate 


def I_S(x): 
    """Sensory input. 

    Parameters 
    ---------- 
    x : number 
     Location of this neuron. 

    Returns 
    ------- 
    float 
     Sensory input to neuron at x. 

    """ 
    S_0 = 0.46 
    S_1 = 0.66 
    x_S = 0 
    sigma_S = 1.31 
    return S_0 + S_1 * np.exp(-0.5 * (x - x_S) ** 2/sigma_S ** 2) 


def I_A(x): 
    """Attentional additive bias. 

    Parameters 
    ---------- 
    x : number 
     Location of this neuron. 

    Returns 
    ------- 
    number 
     Additive bias for neuron at x. 

    """ 
    x_A = 0 
    A_1 = 0.089 
    sigma_A = 0.35 
    A_0 = 0 
    sigma_A_prime = 0.87 
    if np.abs(x - x_A) < l: 
     return (A_1 * np.exp(-0.5 * (x - x_A) ** 2/sigma_A ** 2) + 
       A_0 * np.exp(-0.5 * (x - x_A) ** 2/sigma_A_prime ** 2)) 
    return 0 


def J(dx): 
    """Connection strength. 

    Parameters 
    ---------- 
    dx : number 
     Neuron i's distance from neuron j. 

    Returns 
    ------- 
    number 
     Connection strength. 

    """ 
    J_0 = -2.5 
    J_1 = 8.5 
    sigma_J = 1.31 
    if np.abs(dx) < l: 
     return J_0 + J_1 * np.exp(-0.5 * dx ** 2/sigma_J ** 2) 
    return 0 


if __name__ == '__main__': 

    pass 

Answer 1

Изменение максимальной глубины рекурсии с помощью sys.setrecursionlimit

import sys 
sys.setrecursionlimit(10000) 

def rec(i): 
    if i > 1000: 
     print 'i is over 1000!' 
     return 
    rec(i + 1) 

rec(0) 

Подробнее: https://docs.python.org/3/library/sys.html#sys.setrecursionlimit `

Answer 2

Эта рекурсия никогда не заканчивается, так как не существует условие завершения, прежде чем рекурсивный вызов, регулируя максимальную глубину рекурсии не Помощь

def R(x_i): 
    ... 
    for x_j in x: 
     sum_term += J(x_i - x_j) * R(x_j) 

P возможно, вы должны делать что-то вроде

# some suitable initial guess 
state = guess 

while True: # or a fixed number of iterations 
    next_state = compute_next_state(state) 

    if some_condition_check(state, next_state): 
     # return answer 
     return state 

    if some_other_check(state, next_state): 
     # something wrong, terminate 
     raise ...