Оптимизация на примере. Муравьиный алгоритм (ACS) против Метода отжига. Часть 2

    Продолжаю цикл статей «Оптимизация на примере». В данной статье сравниваются два эвристических алгоритма на избитой симметричной задаче коммивояжера. Сегодня чуть углубимся в данную тему и разберем определенную модификацию муравьиного алгоритма.



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

    Модификация муравьиного алгоритма выбрана ACS (Ant Colony System), которую предложили Марко Дориго и Лука Гамбарделла в 1997 году. Главные отличия от AS (Ant System) это:

    1) задается баланс между самым привлекательным городом, и выбором как в обычном AS

    arg max{[τ(r,u)]^α*[ω(r,u)]^β} если q <= q0 (Формула 1)
    u ϵ Jk«r»

    В обратном случае выбираем переход по AS

    , где [τ(r,u)] — уровень феромона на ребре (r,u), [ω(r,u)] — вес обратный расстоянию на ребре (r,u), β — регулируемый параметр, чем он выше, тем алгоритм будет склонен выбирать город, имеющий меньшее расстояние, α — равна 1, q — случайно выбранное число, q0 — вероятность выбора того, что переход из одной вершины в другую будет идти по формуле 1, u — города, еще не посещенные

    2) помимо глобального обновления феромонов происходит еще и локальное. Уровень феромонов меняется при прохождении каждого муравья на итерации (тут ближе к естественной среде обитания муравьев)

    τ(r,s)=(1-p)*τ(r,s)+p*τ0 (Формула 2)

    , где p — уровень локального обновления, τ0 = значение начального феромона, который вычисляется следующим образом: τ0 = (n*Lnn)^-1, где Lnn — приблизительное оптимальное значение, которое может быть получено другим методом оптимизации.

    3) при глобальном обновлении феромона, добавление происходит только к ребрам, либо лучших со времени начала работы алгоритма (глобальных лучших), либо к ребрам лучших на итерации (локальных лучших). Я применил на ребра глобальных лучших.

    τ(r,s)=(1-e)*τ(r,s)+e*(Lbest^-1) (Формула 3)

    , где e — уровень глобального обновления, Lbest — лучшая длина маршрута (самый короткий), либо на k-ой итерации, либо глобальный лучший.

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

    Теперь будем сравнивать задачи на известных координатах, таких как Oliver30, Eli51, Eli101, на которых найдено лучшее решение. Также выведем приближенные формулы временной зависимости двух алгоритмов от количества городов, и, наконец, попытаемся определить победителя на сегодня с учетом всех этих факторов.

    Начнем с задачи Oliver30 лучшее решение — 423,7406

    Параметры ACS:

    • Количество итераций (поколений) — 2500*
    • Количество муравьев в поколении — 7*
    • Количество городов — 30*
    • альфа (коэф. ориентации на феромоны) — 1
    • бета (коэф. ориентации на длину пути) — 2
    • p (коэф. обновления феромонов локальное) — 0,09
    • e (коэф. обновления феромонов глобальное) — 0,09
    • q (коэф. выбора самого привлекательного города) — 0,9
    • начальное расположение муравьев — случайный

    * — изменяемые параметры от размерности задачи

    Пару слов о количестве муравьев. Ошибкой будет полагать, что чем больше муравьев, тем лучше. При большом количестве муравьев в колонии производительность значительно падает. Во-первых, сильно увеличивается время работы алгоритма. Во-вторых, происходит переизбыток феромонов, что приводит к аналогии в естественной среде, именуемой кругом смерти муравьев. Таким образом, алгоритм застревает на локальном оптимуме.

    Точного определения количества муравьев в колонии пока нет, есть приблизительное вычисление как в [1]. Тут же я старался найти точку оптимума, при которой увеличение количества муравьев не улучшало решение, а их уменьшение снижало результат. Также, если упрощенно, экспериментировал с одной колонией муравьев на определенных итерациях. Как только средний уровень феромона начинал повышаться — брал это за основу оптимального количества муравьев.

    Итак результаты задачи Oliver30:


    Пара графиков:

    Четвертый график показывает, что алгоритм продолжает искать альтернативные пути, не останавливаясь на достигнутом. При увеличении числа муравьев до 50-100 разброс средних дистанций поколения сокращается в пределах 20-30, что приводит к застреванию.

    Полный перебор вариантов для симметричной задачи коммивояжера составляет (n-1)!/2 или
    4 420 880 996 869 850 977 271 808 000 000 для данной задачи

    100% результат, отличная работа ACS

    Посмотрим на метод отжига.

    Параметры:

    • Количество городов — 30*
    • Начальная температура — 35 000*
    • Конечная температура — 0,1
    • Формула температуры — начальную температуру / k-ую итерацию
    • Число итераций — 350 000*
    • Функция вероятности принятия — exp(-ΔE/T)
    • Определение потенциального маршрута (порождающего семейства) — разворот части вектора (текущего маршрута) от двух случайно выбранных чисел равномерным распределением

    * — изменяемые параметры от размерности задачи

    Результаты:


    Как по времени, так и по качеству на 30 городах выигрывает с большим отрывом ACS. Тестировал два алгоритма не только на данной задаче, но и на других 30 — ACS безусловно побеждает простой метод отжига.

    Теперь задача на Eil51 на 51 город, лучшее решение 426, 7000 итераций, кол-во муравьев 9


    Пара графиков:

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

    Пользуясь случаем давайте посмотрим «в реальном режиме» на изменение феромонов от числа итераций, мне данная картинка довольно понравилась.

    Без глобального обновления и с добавлением общего коэффициента испаряемости как в AS, для большего эффекта.

    image

    Смотрим на метод отжига при 2 500 000 итераций


    Довольно неплохой результат, но все же ACS еще впереди.

    Теперь задача Eil101 на 101 город, лучшее расстояние 629, 9000 итераций, кол-во муравьев 11


    Пара графиков:

    Здесь 9000 итераций, довольно мало для 100-ой задачи, однако сравним данный результат с отжигом на том же временном интервале при 7 000 000 итераций.


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

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

    Количество итераций ACS — 10 000, муравьев — 10;
    Количество итераций SA — 7 000 000.


    Ого! Видим, что метод отжига занимает константное время, вне зависимости от количества вершин. Построив регрессию, определяем временную сложность для ACS.

    t = 0.0044939x^2 + 0.72097x + 3.8225 (Формула 4)

    , где x — количество городов, t — время выполнения ACS

    Если же два алгоритма до 100 вершин примерно шли вровень как по времени, так и по качеству (с небольшим опережением ACS), то совсем грубо можно предположить что на 1000 городах, в 10 000 итераций на ACS и в 7 000 000 итераций на SA результат должен быть схожем.

    Проверим.

    ACS 200 городов (случайные города), время — 311,54 с.


    SA 200 городов (те же что и выше), время 103,19 с.


    Запустил последовательно. Какова вероятность того, что оба покажут один результат? Интересный момент вышел, может и сотые доли совпали? Но этого уже не узнать ни Вам, ни мне)

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

    При временном ограничении и количеством вершин больше ста лучше проявляет себя простой метод отжига нежели ACS. Повторюсь, что именно ACS, а не MMAS, ACS local search, либо иная модификация.

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

    Теперь пару слов об ускорении метода имитации отжига.
    Как подсказал читатель daiver19, то, конечно же, не стоит пересчитывать на каждой итерации маршрут.

    Есть условный маршрут:

    1 2 3 4 5 6 7 8 9

    Случайно отобрали два числа, пусть будет (2,5)

    Теперь достаточно посчитать расстояние (1,2) и (5,6) и посчитать расстояние (1,5) и (2,6)

    Однако на асимметричной задаче так не пройдет.

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

    Также одному из читателей интересен был бы результат при перестановке двух вершин, а не инвертировании пути между ними. Давайте посмотрим результат на 101 городах Eil101 на 1 000 000 итераций.


    Инверсия пути значительно лучше.

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

    Сейчас предлагаю посмотреть, как безусловный лидер (пока до 100 вершин) идет к глобальному лучшему пути.


    Также, предлагаю посмотреть на лидера по времени и количеству вершин SA, который выдает приближенное решение 1000 вершин за 4 000 000 итераций в 34 секунды. Если в прошлой статье 2 000 000 итераций для 500 вершин составляло 90 секунд, то сейчас всего 14.6!


    Как-то так. Исходники с комментариями прилагаю. Старался сохранять баланс между читаемостью кода и скоростью. Советую их просмотреть, даже тем кто совсем не знаком с MatLab-ом, так как это сильно поможет вникнуть в суть алгоритмов.

    Имитационный отжиг. Полный код с комментариями
    % метод отжига ( на примере задачи коммивояжера )
    
    %--------------------------------------------------------------------------
    tic
    
    % clearvars -except cities
    clearvars
    
    % -----------------------------ИТЕРАЦИИ------------------------------------
    % кол-во итераций
    m = 1000000;
    % -----------------------------ПАРАМЕТРЫ-----------------------------------
    % начальная температура
    Tstart = 100000;
    
    % конечная температура
    Tend = 0.1;
    
    % начальная температура для вычислений
    T = Tstart;
    
    % расстояние
    S = inf;
    
    % количество городов
    n = 500;
    
    % рисовать графику?
    g = 1;
    
    % --------------------------------ПАМЯТЬ-----------------------------------
    
    % матрица расстояний
    dist = zeros(n,n); 
    
    % -------------------------------------------------------------------------
    
    % генерация городов (x,y)
    cities = rand(n,2)*100;
    
    % формируем заранее список случайных чисел
    RANDONE = rand(m,1);
    
    % формируем два случайных города заранее
    D = randi(n,m,2);
    
    % задаем случайный маршрут
    ROUTE = randperm(n);
    
    % создаем матрицу расстояний
    for i = 1:n
        
        for j = 1:n
            
            % dist ( расстояния )
            dist(i,j) = sqrt((cities(i,1) - cities(j,1))^2 + ...
               (cities(i,2) - cities(j,2))^2);       
                
        end
        
    end
     
    % поехали оптимизировать, время от кол-ва итераций
    for k = 1:m
        
        
        % сбрасываем потенциальное расстояние
        Sp = 0;
        
        % здесь условие создания потенциальных маршрутов, ROUTEp -
        % потенциальный маршрут
        
        % потенциальный маршрут
        ROUTEp = ROUTE;
    
        % два случайных города
        transp = D(k,[1,2]);
        
        % если тут не понятно, посмотрите код из первой части статьи.
        
        if transp(1) < transp(2)
            
            if transp(1) ~= 1 && transp(2) ~= n
                
                S = dist(ROUTE(transp(1)-1),ROUTE(transp(1))) + ...
                    dist(ROUTE(transp(2)),ROUTE(transp(2)+1));
                
            elseif transp(1) ~= 1 && transp(2) == n
                
                S = dist(ROUTE(transp(1)-1),ROUTE(transp(1))) + ...
                    dist(ROUTE(transp(2)),ROUTE(1));
                
            elseif transp(1) == 1 && transp(2) ~= n
                
                S = dist(ROUTE(end),ROUTE(transp(1))) + ...
                     dist(ROUTE(transp(2)),ROUTE(transp(2)+1));
                 
            end           
                
        else
                  
            if transp(2) ~= 1 && transp(1) ~= n
                
                S = dist(ROUTE(transp(2)-1),ROUTE(transp(2))) + ...
                     dist(ROUTE(transp(1)),ROUTE(transp(1)+1));
                
            elseif transp(2) ~= 1 && transp(1) == n
                
                S = dist(ROUTE(transp(2)-1),ROUTE(transp(2))) + ...
                     dist(ROUTE(transp(1)),ROUTE(1));
                
            elseif transp(2) == 1 && transp(1) ~= n
                
                S = dist(ROUTE(end),ROUTE(transp(2))) + ...
                     dist(ROUTE(transp(1)),ROUTE(transp(1)+1));
                 
            end        
        end
        
     %-------------------------------------------------------------------------
        
         if transp(1) < transp(2)
            ROUTEp(transp(1):transp(2)) = ROUTEp(transp(2):-1:transp(1));
            
            if transp(1) ~= 1 && transp(2) ~= n
                
                Sp = dist(ROUTEp(transp(1)-1),ROUTEp(transp(1))) + ...
                    dist(ROUTEp(transp(2)),ROUTEp(transp(2)+1));
                
            elseif transp(1) ~= 1 && transp(2) == n
                
                Sp = dist(ROUTEp(transp(1)-1),ROUTEp(transp(1))) + ...
                    dist(ROUTEp(transp(2)),ROUTEp(1));
                
            elseif transp(1) == 1 && transp(2) ~= n
                
                Sp = dist(ROUTEp(end),ROUTEp(transp(1))) + ...
                     dist(ROUTEp(transp(2)),ROUTEp(transp(2)+1));          
                          
            end           
                
        else
            
            ROUTEp(transp(2):transp(1)) = ROUTEp(transp(1):-1:transp(2));
            
            if transp(2) ~= 1 && transp(1) ~= n
                
                Sp = dist(ROUTEp(transp(2)-1),ROUTEp(transp(2))) + ...
                     dist(ROUTEp(transp(1)),ROUTEp(transp(1)+1));
                
            elseif transp(2) ~= 1 && transp(1) == n
                
                Sp = dist(ROUTEp(transp(2)-1),ROUTEp(transp(2))) + ...
                     dist(ROUTEp(transp(1)),ROUTEp(1));
                
            elseif transp(2) == 1 && transp(1) ~= n
                
                Sp = dist(ROUTEp(end),ROUTEp(transp(2))) + ...
                     dist(ROUTEp(transp(1)),ROUTEp(transp(1)+1));            
                 
            end        
         end
        
    %--------------------------------------------------------------------------    
        if Sp < S
            ROUTE = ROUTEp;
            iter = k;                          
        else
    
            % вычисляем вероятность перехода
            P = exp((-(Sp - S)) / T);
           
                if RANDONE(k) <= P
                    ROUTE = ROUTEp;                          
                end
            
        end
        
        	% уменьшаем температуру
            T = Tstart / k;
    
            % проверяем условие выхода
            if T < Tend
                break;
            end;      
    end
    
    % рисуем графику
    citiesOP(:,[1,2]) = cities(ROUTE(:),[1,2]);
    plot([citiesOP(:,1);citiesOP(1,1)],[citiesOP(:,2);citiesOP(1,2)],'-r.')
    
    msgbox ('Выполнено!')
    
    % очищаем переменые
    clearvars -except cities ROUTE S iter
    
    % смотрим время
    toc
    



    Муравьиный алгоритм. Полный код с комментариями
    % муравьиный алгоритм ( на примере задачи коммивояжера )
    
    % -------------------------------------------------------------------------
    tic
    
    % clearvars -except cities
    clearvars
     
    % ------------------------------ИТЕРАЦИИ-----------------------------------
    
    % кол-во итераций ( поколений )
    age = 2000;
    
    % кол-во муравьев в поколении
    countage = 10;
    
    % кол-во городов
    n = 50;
    
    % ------------------------------ПАРМЕТРЫ-----------------------------------
    
    % альфа - коэффициент запаха, при 0 будем ориентироваться только на
    % кратчайший путь 
    a = 1; 
    
    % бета - коэффициент расстояния, при 0 будем
    % ориентироваться только на оставляемый запах
    b = 2;
    
    % коэффициент обновления, глобальное
    e = 0.1;
    
    % коэффициент обновления, локальное
    p = 0.1;
    
    % количество выпускаемых феромонов 
    Q = 1;
    
    % баланс между лучшим городом и как в AS
    q = 0.9;
    
    % начальный феромон
     ph = Q/(n*2000);
    
    % -------------------------------ПАМЯТЬ------------------------------------
    % матрица расстояний
    dist = zeros(n,n); 
    
    % матрица обратных расстояний
    returndist = zeros(n,n); 
    
    % матрица маршрута муравьев в одном поколении
    ROUTEant = zeros(countage,n);
    
    % вектор расстояний муравьев в одном поколении
    DISTant = zeros(countage,1); 
    
    % вектор лучших дистанций на каждой итерации
    bestDistVec = zeros(age,1);
    
    % лучший начальный маршрут
    bestDIST = inf; 
    
    % оптимальные маршруты
    ROUTE = zeros(1,n+1);
    
    % перестановка городов без повторений ( для выхода муравьев )
    RANDperm = randperm(n);
    
    % матрица вероятностей
    P = zeros(1,n);
    
    % максимальное значение вероятности
    val = zeros(1);
    
    % присваем номер города
    getcity = zeros(1);
    
    % индекс максимального значения вероятности
    indexP = zeros(1);
    
    % максимальное
    minDISTiterration = zeros(1);
    
    % -------------------------------------------------------------------------
    
    % генерация городов (x,y)
    cities = rand(n,2)*100;
    
    % матрица начальных феромонов
    tao = ph*(ones(n,n));
    tao(logical(eye(size(tao)))) = 0;
    
    % создаем матрицу расстояний и матрицу обратных расстояний
    for i = 1:n
        
        for j = 1:n
            
            % dist ( расстояния )
            dist(i,j) = sqrt((cities(i,1) - cities(j,1))^2 + ...
               (cities(i,2) - cities(j,2))^2);
            
                % nn ( обратные расстояния )
                if i ~= j
                returndist(i,j) = 1/sqrt((cities(i,1) - cities(j,1))^2 + ...
                    (cities(i,2) - cities(j,2))^2); 
                end
                
        end
        
    end
    
    % итерации
    for iterration = 1:age
        
        
        % муравьи ( одно поколение)
        for k = 1:countage
            
        % ****************** НАЧАЛЬНОЕ РАСПОЛОЖЕНИЕ МУРАВЬЕВ ******************
        % выбирайте какой нужно
        
        % каждый муравей располагается случайно    
          ROUTEant(k,1) = randi([1 n]);
        
        % с каждого города выходит один муравей ( без совпадений ), кол-во
        % городов и кол-во муравьев в поколении должны быть равны
    %       ROUTEant(k,1) = RANDperm(k);
        
        % с конкретного города выходят все муравьи в данном случа с 1-ого
    %       ROUTEant(k,1) = 1;
    
    % тут маршрут первому поколению задаем либо произвольный, либо с каждого
    % города разный, либо с одного города все, а следующее поколение выходит по
    % концам первых
    
    %     if iterration == 1
    %       ROUTEant(k,1) = randi([1 n]);
    % %       ROUTEant(k,1) = RANDperm(k);
    % %     ROUTEant(k,1) = 1;
    %     else
    %       ROUTEant(k,1) = lastROUTEant(k);  
    %     end
        
        % *********************************************************************
        
        % путь каждого муравья, начиная со второго, так как первый выбран
        for s = 2:n  
    
            % полуаем индекс выбранного города
            ir = ROUTEant(k,s-1);
     
            % вероятность посещения городов ( числитель ) , в числителе у нас
            % следующее: tao^a*(1/S)^b 
            % 1/S -это returndist. 
            
            % поскольку данное значение будет повторяться (кол-во муравьев * на
            % колонию * кол-во городов) раз, то еще один цикл писать не выгодно,
            % скорость работы при таких вычислениях падает. Поэтому написал в 
            % этом моменте векторно. На обычном языке будет так: 
            
    %         for c = 1:n             
    %             P(1,c) = tao(ir,c).^a * returndist(ir,c).^b;          
    %         end
    
            P = tao(ir,:).^a .* returndist(ir,:).^b;
            % получили числители (в формуле вероятности перехода к k-ому городу)
            % для n городов, однако в некоторых мы уже побывали, нужно исключить
            % их
            
            % проставляем нули в числитель туда, где уже были, чтобы
            % вероятность перехода была 0, следовательно в сумме знаменателя
            % формулы данный город учитываться не будет    
            P(ROUTEant(k,1:s-1)) = 0;
            
            % смотрим в какой город осуществляется переход
            RANDONE = rand;
            
            if RANDONE <= q
                [val, getcity] = max(P);
            else
                % получаем вероятности перехода ( сумма строк должна быть = 1 )
                P = P ./ sum(P);
                getcity = find(cumsum(P) >= RANDONE, 1, 'first');
            end
            
            % присваем s-ый город в путь k-ому муравью
            ROUTEant(k,s) = getcity;
    
        end
            
        % получаем маршрут k-ого муравья
        ROUTE = [ROUTEant(k,1:end),ROUTEant(k,1)];
        
        % сброс длины
        S = 0;
        
        % вычисляем маршрут k-ого муравья
        for i = 1:n
            S = S + dist(ROUTE(i),ROUTE(i+1));
        end
        
        % путь k-ого муравья, массив дистанций k-ых муравьев age-ого поколения
        DISTant(k) = S;
        
        % присваевыем лучший маршрут и S     
        if DISTant(k) < bestDIST
            bestDIST = DISTant(k);
            bestROUTE = ROUTEant(k,[1:end,1]); 
            iter = iterration;
        end
        
        % вектор "последних" городов k-ых муравьев ( выбирается для старта
        % муравьев нового поколения с тех городов, где закончили путь
        % предыдущее поколение)
        
        % lastROUTEant = ROUTEant(1:end,end); 
       
        % локальное обновление феромона, после  каждого муравья
        for tL = 1:n
    
            xL = ROUTE(tL);
            yL = ROUTE(tL+1);
    
            % считаем новый феромон
            tao(xL,yL) = (1-p)*tao(xL,yL) + p*ph;
            tao(yL,xL) = (1-p)*tao(yL,xL) + p*ph;
            
        end   
        
        end
    % --------------------------ГЛОБАЛЬНОЕ ОБНОВЛЕНИЕ--------------------------
    
        % Испаряем феромоны "старого" пути е - коэффициент испарения
        
        tao(tao < 2.500000000000000e-150) = 2.500000000000000e-150;
        
            % для каждого города
            for t = 1:n
                
                xG = bestROUTE(t);
                yG = bestROUTE(t+1);
                
                % считаем новый феромон
                tao(xG,yG) = tao(xG,yG) + e*(Q/bestDIST); 
                tao(yG,xG) = tao(yG,xG) + e*(Q/bestDIST);
                
            end
            
    end 
    
    % строим графику
    citiesOP(:,[1,2]) = cities(bestROUTE(:),[1,2]);
    plot([citiesOP(:,1);citiesOP(1,1)],[citiesOP(:,2);citiesOP(1,2)],'.r-')
    
    disp (num2str(bestDIST))
    
    msgbox ('Выполнено!')
    
    clearvars -except cities bestDIST bestROUTE iter
    
    toc
    



    Спасибо за внимание. До новых встреч.

    Статьи зарубежных авторов:

    [1] — M. Dorigo, L. M. Gambardella, Ant Colony System: A Cooperative Learning Approach to the Traveling Salesman Problem // IEEE Transactions on Evolutionary Computation Vol. 1, 1, стр. 53-66, 1997 г.

    [2] T. Stützle, H. Hoos, “MAX-MIN Ant System and local search for the traveling salesman problem” // IEEE International Conference on Evolutionary Computation, стр. 309-314, 1997 г.

    [3] T. Stützle, M. López-Ibáñez, P. Pellegrini, M. Maur, M. de Oca, M. Birattari, Michael Maur, M. Dorigo, “Parameter Adaptation in Ant Colony Optimization” // Technical Report, IRIDIA, Université Libre de Bruxelles, 2010 г.
    • +21
    • 7,9k
    • 7
    Поделиться публикацией
    Похожие публикации
    AdBlock похитил этот баннер, но баннеры не зубы — отрастут

    Подробнее
    Реклама
    Комментарии 7
    • 0
      Спасибо за статью! Интересные результаты.

      Я использую отжиг для обора информативных переменных. Размерность например 10 из 100. Но не могу сказать, что на больших задачах получаю глобальный максимум. Скорее, приближение.

      Даже были неоднократные примеры, когда жадный поиск перещеголял стохастический. А времени в 100 раз меньше тратил.
      • 0
        Сравним и с жадными тогда. Думаю будет интересно)
        • 0
          Писал курсовую по этим двум алгоритмам на базе задачи коммивояжера. Муравьи намного состоятельнее оказались на больших графах(больше сотни вершин).Вот так выглядит график сходимости(длина найденного цикла от количества итераций) отжига на графе в 1655 вершин:
          image
          Вот так для муравьёв:
          image
          Тут время работы по параметрам я примерно одинаковое подбирал. И отжиг слабенько себя показал(может я настроить не смог толково). Вот муравьи показались интереснее. Много всякого смог оптимизировать.

          Когда-то думал статью впилить об оптимизациях этого алгоритма, но и так пруд пруди на хабре уже подообного и лень взяла верх
          • 0
            Про муравьиные алгоритмы на Хабре совсем мало статей) Какая была модификация муравьиного алгоритма? Может скорость отжига была небольшой?) Конечно сложно судить по одному графику, но вроде бы у муравьиного алгоритма был высокий коэффициент обновления феромонов, что сильно сокращает время алгоритма, также как и вероятность нахождения глобального оптимума. В данной статье алгоритм настраивал на глобальный путь, поэтому по времени пока проиграл. Если будет желание и время, то, конечно, напишите статью, будет интересно)
            • 0
              Сомтрел что там на 50 итерации такого происходит. Выводил процент от всех феромонов, которые лежат на наилучшем найденном пути. Было вроде такого:
              0.2
              0.2
              0.2
              0.2
              0.3
              4.2 < — 50-ая итерация
              19.1
              24.8
              26.0
              28.6
              31.3
              На 50-ой итерации видимочень резкий скачокю Тут уровень испарения 0.2. Сравните с P=0.1:
              0.2
              0.2
              0.2
              0.2
              0.2
              0.2
              0.2
              0.2
              0.3
              0.8
              3.9
              Очень медленно сходится, а результат в итоге тот же самый был.

              Чуть позже может отдельно по муравьиному запилю пост. Я там всякие интересности наблюдал. По отжигу ничего интересного не получилось
            • 0
              Все таки 350 итераций для 1655 вершин очень мало, может у Вас собственная какая-то разработка. Конечно, напишите, я же тогда еще реализую различные модификации в следующих статьях. Может сойдемся на каких-либо результатах)
              • 0
                Так а толку дальше гонять, если там почти нет улучшений? Ну и медленно работает, да. Я позже находил места где можно было мой код на джава ускорить, но не до того было. У меня 40 муравьёв бегало(если говорить о представленном графике). Хотя это до улучшений(запустил на большом наборе данных и дорабатывал). Вот таблица для сравнения на этом графе после всех моих оптимизаций:
                image
                То есть примерно в 35 раз ускорил работу=)
                Постараюсь на выходных выложить подробнее о том, как процесс оптимизации проходил.

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