Как эффективно проходить функцию через?

Учитывая кривую красного, синего и зеленого. Я бы хотел найти в каждой точке оси x доминирующую кривую. Это показано как черная графа на картинке. Из свойств красной, зеленой и синей кривой (возрастающей и постоянной через некоторое время) это сводится к тому, чтобы найти доминирующую кривую с правой стороны, а затем двигаться в сторону левой стороны, находить все точки пересечения и обновлять доминирующие кривая.

Эта общая задача должна быть решена T раза. В этой проблеме есть один последний поворот. Синяя, зеленая и красная кривые следующей итерации строятся через доминирующее решение из предыдущей итерации плюс некоторые различные параметры. В качестве примера на рисунке выше: Решение - черная функция. Эта функция используется для создания новой синей, зеленой и красной кривой. Затем проблема снова начнется, чтобы найти доминирующую для этих новых кривых и т.д.

Вопрос в двух словах
На каждой итерации я начинаю с фиксированной правой стороны и оцениваю все три функции, чтобы увидеть, какая из них является доминирующей. Эти оценки занимают больше времени и больше по сравнению с итерацией. Мое ощущение состоит в том, что я не передаю оптимально старой доминирующей функции, чтобы построить новую синюю, зеленую и красную кривые. Причина. Я получил более раннюю версию ошибки максимальной глубины рекурсии. Другие части кода, в которых требуется значение текущей доминирующей функции (которая является существенной или зеленой, красной или синей кривой), также занимают больше времени и больше с итерацией.

В течение 5 итераций возрастает только оценка функций в одной точке с правой стороны:

Я хотел бы знать, почему это так, и если можно запрограммировать его более эффективно.

Я быстро обобщаю наиболее важные функции. Полный код можно найти ниже. Если есть какие-либо другие вопросы относительно кода, я более чем счастлив разработать/уточнить.

Ответы

Ответ 1

Ваш код действительно слишком сложный, чтобы объяснить вашу проблему. Стремитесь к чему-то более простому. Иногда вам приходится писать код, чтобы продемонстрировать проблему.

Я принимаю удар, основанный исключительно на вашем описании, а не на вашем коде (хотя я запустил код и проверил). Вот ваша проблема:

метод eval: это основная функция генерации синего, зеленого и красные версии каждый раз. Требуется три различных параметра: каждый итерация: vfunction, которая является доминирующей функцией из предыдущий шаг, m и s, которые являются двумя параметрами (флеотами), влияющими на формы результирующей кривой.

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

Как вы можете избежать этого? Там нет простого или встроенного способа. Самый простой ответ - при условии, что входные данные для этих функций согласованы - сохранить функциональный результат (т.е. Числа), а не сами функции. Вы можете сделать это, пока у вас есть конечное число известных входов.

Если входы базовых функций не согласованы, то нет ярлыка. Вам нужно многократно оценивать эти основные функции. Я вижу, что вы выполняете кусочно сплайсинг базовых функций - вы можете проверить, стоит ли затратить на это расходы, просто беря max каждой из основных функций.

Тест, который я выполнил (10 итераций), занял несколько секунд. Я не вижу в этом проблемы.

Ответ 2

Давайте начнем с изменения кода для вывода текущей итерации:

_u = self.u
for t in range(0, self.T):
    print(t)
    lparams = np.random.randint(self.a, self.b, 6).reshape(3, 2).tolist()
    functions = [self._function_template(_u, *lparams[i])
                 for i in range(0, 3)]
    # evaluate functions
    pairs = list(itertools.combinations(functions, 2))
    fval = [F(diff(*pairs[i]), self.a, self.b) for i in range(0, 3)]
    ind = np.sort(np.unique(np.random.randint(self.a, self.b, 10)))
    _u = _temp(ind, np.asarray(functions)[ind % 3])

Заглядывая в строку, вызывающую поведение,

fval = [F(diff(*pairs[i]), self.a, self.b) for i in range(0, 3)]

представляющие интерес функции будут F и diff. Последнее простое, первое:

def F(f, a, b):
    try:
        brentq(f, a=a, b=b)
    except ValueError:
        pass

Хмм, проглатывая исключения, посмотрим, что получится, если мы:

def F(f, a, b):
    brentq(f, a=a, b=b)

Сразу же для первой функции и первой итерации возникает ошибка:

ValueError: f (a) и f (b) должны иметь разные знаки

Глядя на docs, это является обязательным условием функции поиска корня brentq. Позвольте изменить определение еще раз, чтобы контролировать это условие на каждой итерации.

def F(f, a, b):
    try:
        brentq(f, a=a, b=b)
    except ValueError as e:
        print(e)

Выходной сигнал

i
f(a) and f(b) must have different signs
f(a) and f(b) must have different signs
f(a) and f(b) must have different signs

для i в диапазоне от 0 до 57. Значение, когда функция F всегда выполняет какую-либо реальную работу для i=58. И он продолжает делать это для более высоких значений i.

Заключение: для этих более высоких значений требуется больше времени, потому что:

корень никогда не вычисляется для более низких значений
число вычислений растет линейно для i>58