Что такое memoization и как я могу использовать его в Python?

Ответ 1

Воспоминание эффективно относится к запоминанию ( "воспоминания" → "меморандум" → для запоминания) результаты вызовов методов на основе входных данных метода, а затем возврат запоминаемого результата, а не повторение результата. Вы можете думать об этом как кэш для результатов метода. Более подробную информацию см. на стр. 387 для определения в Введение в алгоритмы (3е), Cormen и др.

Простым примером для вычисления факториалов с использованием memoization в Python было бы примерно так:

factorial_memo = {}
def factorial(k):
    if k < 2: return 1
    if k not in factorial_memo:
        factorial_memo[k] = k * factorial(k-1)
    return factorial_memo[k]

Вы можете усложниться и инкапсулировать процесс memoization в класс:

class Memoize:
    def __init__(self, f):
        self.f = f
        self.memo = {}
    def __call__(self, *args):
        if not args in self.memo:
            self.memo[args] = self.f(*args)
        return self.memo[args]

Тогда:

def factorial(k):
    if k < 2: return 1
    return k * factorial(k - 1)

factorial = Memoize(factorial)

В Python 2.4 добавлена ​​функция, известная как decorators", которая позволяет вам просто написать следующее, чтобы выполнить одно и то же:

@Memoize
def factorial(k):
    if k < 2: return 1
    return k * factorial(k - 1)

Библиотека декораторов Python имеет аналогичный декоратор под названием memoized, который немного более устойчив, чем класс Memoize, показанный здесь.

Ответ 2

Новый для Python 3.2 functools.lru_cache. По умолчанию он кэширует только 128 последних вызовов, но вы можете установить maxsize в None, чтобы указать, что кеш никогда не истекает:

import functools

@functools.lru_cache(maxsize=None)
def fib(num):
    if num < 2:
        return num
    else:
        return fib(num-1) + fib(num-2)

Эта функция сама по себе очень медленная, попробуйте fib(36), и вам придется подождать около десяти секунд.

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

Ответ 3

Другие ответы охватывают то, что хорошо. Я не повторяю этого. Просто некоторые моменты, которые могут быть полезны для вас.

Обычно memoisation - это операция, которую вы можете применить к любой функции, которая вычисляет что-то (дорогое) и возвращает значение. Из-за этого он часто реализуется как декоратор. Реализация прост, и это будет что-то вроде этого

memoised_function = memoise(actual_function)

или выражается в качестве декоратора

@memoise
def actual_function(arg1, arg2):
   #body

Ответ 4

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

Вот пример:

def doSomeExpensiveCalculation(self, input):
    if input not in self.cache:
        <do expensive calculation>
        self.cache[input] = result
    return self.cache[input]

Более полное описание можно найти в записи wikipedia в memoization.

Ответ 5

Не забывайте встроенную функцию hasattr, для тех, кто хочет использовать ручной инструмент. Таким образом, вы можете хранить кеш-память внутри определения функции (в отличие от глобального).

def fact(n):
    if not hasattr(fact, 'mem'):
        fact.mem = {1: 1}
    if not n in fact.mem:
        fact.mem[n] = n * fact(n - 1)
    return fact.mem[n]

Ответ 6

Я нашел это чрезвычайно полезным

def memoize(function):
    from functools import wraps

    memo = {}

    @wraps(function)
    def wrapper(*args):
        if args in memo:
            return memo[args]
        else:
            rv = function(*args)
            memo[args] = rv
            return rv
    return wrapper


@memoize
def fibonacci(n):
    if n < 2: return n
    return fibonacci(n - 1) + fibonacci(n - 2)

fibonacci(25)

Ответ 7

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

см. http://scriptbucket.wordpress.com/2012/12/11/introduction-to-memoization/

Пример Memoization Фибоначчи в Python:

fibcache = {}
def fib(num):
    if num in fibcache:
        return fibcache[num]
    else:
        fibcache[num] = num if num < 2 else fib(num-1) + fib(num-2)
        return fibcache[num]

Ответ 8

Запоминание - это преобразование функций в структуры данных. Обычно требуется, чтобы преобразование происходило постепенно и лениво (по запросу данного элемента домена - или "ключ" ). В ленивых функциональных языках это ленивое преобразование может происходить автоматически, и, таким образом, мемонирование может быть реализовано без (явных) побочных эффектов.

Ответ 9

Вот решение, которое будет работать со списком или аргументом типа dict без завивания:

def memoize(fn):
    """returns a memoized version of any function that can be called
    with the same list of arguments.
    Usage: foo = memoize(foo)"""

    def handle_item(x):
        if isinstance(x, dict):
            return make_tuple(sorted(x.items()))
        elif hasattr(x, '__iter__'):
            return make_tuple(x)
        else:
            return x

    def make_tuple(L):
        return tuple(handle_item(x) for x in L)

    def foo(*args, **kwargs):
        items_cache = make_tuple(sorted(kwargs.items()))
        args_cache = make_tuple(args)
        if (args_cache, items_cache) not in foo.past_calls:
            foo.past_calls[(args_cache, items_cache)] = fn(*args,**kwargs)
        return foo.past_calls[(args_cache, items_cache)]
    foo.past_calls = {}
    foo.__name__ = 'memoized_' + fn.__name__
    return foo

Обратите внимание, что этот подход может быть естественным образом распространен на любой объект, реализуя собственную хэш-функцию как особый случай в handle_item. Например, чтобы этот подход работал для функции, которая принимает набор в качестве входного аргумента, вы можете добавить handle_item:

if is_instance(x, set):
    return make_tuple(sorted(list(x)))

Ответ 10

Ну, я должен сначала ответить на первую часть: какая memoization?

Это просто метод для торговли памятью во времени. Подумайте о Таблица умножения.

Использование изменяемого объекта в качестве значения по умолчанию в Python обычно считается плохим. Но если использовать его с умом, на самом деле может быть полезно реализовать memoization.

Здесь приведен пример из http://docs.python.org/2/faq/design.html#why-are-default-values-shared-between-objects

Используя измененный dict в определении функции, промежуточные вычисленные результаты могут быть кэшированы (например, при вычислении factorial(10) после вычисления factorial(9), мы можем повторно использовать все промежуточные результаты)

def factorial(n, _cache={1:1}):    
    try:            
        return _cache[n]           
    except IndexError:
        _cache[n] = factorial(n-1)*n
        return _cache[n]

Ответ 11

cache = {}
def fib(n):
    if n <= 1:
        return n
    else:
        if n not in cache:
            cache[n] = fib(n-1) + fib(n-2)
        return cache[n]

Ответ 12

Решение, которое работает как с аргументами positional, так и с ключевыми словами независимо от порядка, в котором передавались ключевые слова args (используя inspect.getargspec):

import inspect
import functools

def memoize(fn):
    cache = fn.cache = {}
    @functools.wraps(fn)
    def memoizer(*args, **kwargs):
        kwargs.update(dict(zip(inspect.getargspec(fn).args, args)))
        key = tuple(kwargs.get(k, None) for k in inspect.getargspec(fn).args)
        if key not in cache:
            cache[key] = fn(**kwargs)
        return cache[key]
    return memoizer

Аналогичный вопрос: Идентификация эквивалентных вызовов функции varargs для memoization в Python

Ответ 13

Просто хотел добавить к уже предоставленным ответам, библиотека декораторов Python имеет несколько простых, но полезных реализаций, которые также могут memoize "unhashable types", в отличие от functools.lru_cache.