Эффективная реализация дерева в MATLAB

Ответ 1

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

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

Причины, о которых я говорю, следующие:

• Чтобы вставить вам вызов stree.addnote(parent, data), который будет хранить все данные в полях дерева stree Node = {} и Parent = []
• вам, кажется, известно, какой элемент в вашем дереве вы хотите получить, поскольку код поиска не указан (если вы используете stree.getchild(ID) для него, у меня есть плохие новости)
• После того, как вы обработали node, вы трассируете его с помощью find(), который является поиском по списку

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

Хранить данные в виде таблицы поиска

Одним из способов хранения данных является сохранение базовой таблицы поиска. Я бы сделал это, только если вы знаете ID первого элемента, который вы хотите изменить , не ища его. Этот случай позволяет сделать вашу структуру более эффективной в два этапа.

Сначала инициализируйте массивы больше, а затем ожидайте, что вам нужно сохранить данные. Если превышена пропускная способность таблицы вверх, будет инициализирована новая, которая больше X-полей и будет сделана глубокая копия старых данных. Если вам нужно увеличить количество экземпляров один или два раза (во время всех вставок), это может не быть проблемой, но в вашем случае глубокая копия будет сделана навсегда!

Во-вторых, я бы изменил внутреннюю структуру и объединил две таблицы Node и parent. Причина этого в том, что обратное распространение в вашем коде принимает O (depth_from_root * n), где n - количество узлов в вашей таблице. Это потому, что find() будет перебирать всю таблицу для каждого родителя.

Вместо этого вы можете реализовать что-то похожее на

table = cell(n,1) % n bigger then expected value
end_pointer = 1 % simple pointer to the first free value

function insert(data,parent_ID)
    if end_pointer < numel(table)
        content.data = data;
        content.parent = parent_ID;
        table{end_pointer} = content;
        end_pointer = end_pointer + 1;
    else
        % need more space, make sure its enough this time
        table = [table cell(end_pointer,1)];
        insert(data,parent_ID);
    end
end

function content = get_value(ID)
    content = table(ID);
end

Это мгновенно дает вам доступ к родительскому ID без необходимости find(), сначала, сохраняя n итераций на каждом шаге, поэтому вы можете получить O (глубина). Если вы не знаете свой начальный node, тогда вы должны find() указать тот, который стоит O (n).

Обратите внимание, что эта структура не нуждается в is_leaf(), depth(), nnodes() или get_children(). Если вам все еще нужны те, мне нужно больше понять, что вы хотите делать с вашими данными, так как это очень влияет на правильную структуру.

Структура дерева

Эта структура имеет смысл, если вы никогда не знаете первый node ID и, следовательно, всегда должны искать для него.

Преимущество состоит в том, что поиск произвольной ноты работает с O (глубина), поэтому поиск O (глубина) вместо O (n), а обратное распространение - O (глубина ^ 2) вместо O (глубина + n). Обратите внимание, что глубина может быть чем угодно: от log (n) для идеально сбалансированного дерева, которое может быть возможно в зависимости от ваших данных, до n для вырожденного дерева, которое является связанным списком.

Однако, чтобы предложить что-то надлежащее, мне потребовалось бы более глубокое понимание, так как каждый вид древовидной структуры имеет свой собственный nich. Из того, что я вижу до сих пор, я предлагаю несимметричное дерево, которое "сортируется" по простому порядку, заданному узлом, которым нужен родитель. Это может быть дополнительно оптимизировано в зависимости от

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

Я с удовольствием предоставил бы пример кода для вышеупомянутого дерева, просто оставьте комментарий.

EDIT: В вашем случае оптимальным вариантом является неуравновешенное дерево (то есть параллельное исполнение для MCTS). В приведенном ниже коде предполагается, что данные разделены на state и score, а кроме того, a state является уникальным. Если это не так, это все равно будет работать, однако есть возможная оптимизация для повышения производительности MCTS.

classdef node < handle
    % A node for a tree in a MCTS
    properties
        state = {}; %some state of the search space that identifies the node
        score = 0;
        childs = cell(50,1);
        num_childs = 0;
    end
    methods
        function obj = node(state)
            % for a new node simulate a score using MC
            obj.score = simulate_from(state); % TODO implement simulation state -> finish
            obj.state = state;
        end
        function value = update(obj)
            % update the this node using MC recursively
            if obj.num_childs == numel(obj.childs)
                % there are to many childs, we have to expand the table
                obj.childs = [obj.childs cell(obj.num_childs,1)];
            end
            if obj.do_exploration() || obj.num_childs == 0
                % explore a potential state
                state_to_explore = obj.explore();

                %check if state has already been visited
                terminate = false;
                idx = 1;
                while idx <= obj.num_childs && ~terminate
                    if obj.childs{idx}.state_equals(state_to_explore)
                        terminate = true;
                    end
                    idx = idx + 1;
                end

                %preform the according action based on search
                if idx > obj.num_childs
                    % state has never been visited
                    % this action terminates the update recursion 
                    % and creates a new leaf
                    obj.num_childs = obj.num_childs + 1;
                    obj.childs{obj.num_childs} = node(state_to_explore);
                    value = obj.childs{obj.num_childs}.calculate_value();
                    obj.update_score(value);
                else
                    % state has been visited at least once
                    value = obj.childs{idx}.update();
                    obj.update_score(value);
                end
            else
                % exploit what we know already
                best_idx = 1;
                for idx = 1:obj.num_childs
                    if obj.childs{idx}.score > obj.childs{best_idx}.score
                        best_idx = idx;
                    end
                end
                value = obj.childs{best_idx}.update();
                obj.update_score(value);
            end
            value = obj.calculate_value();
        end
        function state = explore(obj)
            %select a next state to explore, that may or may not be visited
            %TODO
        end
        function bool = do_exploration(obj)
            % decide if this node should be explored or exploited
            %TODO
        end
        function bool = state_equals(obj, test_state)
            % returns true if the nodes state is equal to test_state
            %TODO
        end
        function update_score(obj, value)
            % updates the score based on some value
            %TODO
        end
        function calculate_value(obj)
            % returns the value of this node to update previous nodes
            %TODO
        end
    end
end

Несколько комментариев к коду:

• в зависимости от настройки obj.calculate_value() может и не понадобиться. Например. если это какое-то значение, которое может быть вычислено путем оценки только дочерних показателей
• Если a state может иметь несколько родителей, имеет смысл повторно использовать объект примечания и покрыть его в структуре
• поскольку каждый Node знает все его дочерние элементы, поддерево может быть легко сгенерировано с помощью Node как root node
• поиск дерева (без какого-либо обновления) - это простой рекурсивный жадный поиск
• в зависимости от фактора разветвления вашего поиска, возможно, стоит посетить каждый возможный дочерний один раз (после инициализации node), а затем выполнить randsample(obj.childs,1) для исследования, поскольку это позволяет избежать копирования/перераспределения дочернего массива
• свойство parent кодируется, когда дерево обновляется рекурсивно, передавая value родительскому элементу после завершения обновления для node
• Единственное время, когда я перераспределяю память, - это когда один node имеет более 50 дочерних элементов, я только перераспределяю для этого отдельного node

Это должно работать намного быстрее, поскольку оно просто беспокоится о том, какая часть дерева выбрана и не трогает ничего.

Ответ 2

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

Еще одно улучшение voodoo будет перемещаться .maxSize рядом с .num_nodes и помещать их перед ячейкой .Node. Таким образом, их положение в памяти не изменится относительно начала объекта из-за роста свойства .Node (вуду здесь, когда я угадываю внутреннюю реализацию объектов в MATLAB).

Позднее редактирование. Когда я профилировал с .Node, перемещенным в конце списка свойств, основная часть времени выполнения была потреблена путем расширения свойства .Node, как и ожидалось (5.45 секунды, по сравнению с 1,25 с для сравнения, о котором вы упомянули).

Ответ 3

Вы можете попытаться выделить несколько элементов, которые пропорциональны количеству фактически заполненных элементов: это стандартная реализация для std::vector в С++

obj.Node = [obj.Node; data; cell(q * obj.num_nodes,1)];

Я точно не помню, но в MSCC q равен 1, а для GCC - 0,75.

Это решение с использованием Java. Мне это не очень нравится, но он выполняет свою работу. Я реализовал пример, извлеченный из википедии.

import javax.swing.tree.DefaultMutableTreeNode

% Let create our example tree
top = DefaultMutableTreeNode([11,21])
n1 = DefaultMutableTreeNode([7,10])
top.add(n1)
n2 = DefaultMutableTreeNode([2,4])
n1.add(n2)
n2 = DefaultMutableTreeNode([5,6])
n1.add(n2)
n3 = DefaultMutableTreeNode([2,3])
n2.add(n3)
n3 = DefaultMutableTreeNode([3,3])
n2.add(n3)
n1 = DefaultMutableTreeNode([4,8])
top.add(n1)
n2 = DefaultMutableTreeNode([1,2])
n1.add(n2)
n2 = DefaultMutableTreeNode([2,3])
n1.add(n2)
n2 = DefaultMutableTreeNode([2,3])
n1.add(n2)
n1 = DefaultMutableTreeNode([0,3])
top.add(n1)

% Element to look for, your implementation will be recursive
searching = [0 1 1];
idx = 1;
node(idx) = top;
for item = searching,
    % Java transposes the matrices, remember to transpose back when you are reading
    node(idx).getUserObject()'
    node(idx+1) = node(idx).getChildAt(item);
    idx = idx + 1;
end
node(idx).getUserObject()'

% We made a new test...
newdata = [0, 1]
newnode = DefaultMutableTreeNode(newdata)
% ...so we expand our tree at the last node we searched
node(idx).add(newnode)

% The change has to be propagated (this is where your recursion returns)
for it=length(node):-1:1,
    itnode=node(it);
    val = itnode.getUserObject()'
    newitemdata = val + newdata
    itnode.setUserObject(newitemdata)
end

% Let see if the new values are correct
searching = [0 1 1 0];
idx = 1;
node(idx) = top;
for item = searching,
    node(idx).getUserObject()'
    node(idx+1) = node(idx).getChildAt(item);
    idx = idx + 1;
end
node(idx).getUserObject()'