Оптимизация операций с матрицами

Я оптимизирую с помощью генетического алгоритма симулятор машины (машины MultiheadWeigher), чтобы решить известную «проблему настройки». Я основывал весь код на матрицах, но с многопродуктовым случаем я думаю есть еще какая-то неэффективность...

Код

function [f] = MHW(position_matrix, HA, HB, HC)

global W_best_tot
global Function
global n_b_global

nComb = size(position_matrix,1);
dim = size(position_matrix,2);

WL = 241;

%SIMULATIONS VARIABLES
alpha = 0.123;
nSim = 3000;
CellUncertainty = 0.5 * 10^(-6);

%// Define Product Hopper allocation
WT_A = 130; WL_A = 129;
WT_B = 30; WL_B = 29;
%HC = 2; 
WT_C = 90; WL_C = 89;

%// COMBINATION MATRIX

CombinantionMatrix_A = combn([0 1], HA);
CombinantionMatrix_B = combn([0 1], HB);
CombinantionMatrix_C = combn([0 1], HC);

if HA == 1
    CombinantionMatrix_A = CombinantionMatrix_A.';
end
if HB == 1
    CombinantionMatrix_B = CombinantionMatrix_B.';
end
if HC == 1
    CombinantionMatrix_C = CombinantionMatrix_C.';
end

CombinantionMatrix_A_Transp = CombinantionMatrix_A.';
CombinantionMatrix_B_Transp = CombinantionMatrix_B.';
CombinantionMatrix_C_Transp = CombinantionMatrix_C.';

% OBJECTIVE FUNCTION COST COEFFICIENTS
Cu_A = 0.03; c_p = 0.6; c_f = 734; c_l = 3.2;
Cu_B = 0.09;
Cu_C = 0.04;

[HopperWeight UncertainWeight] = Weight(nComb, dim, alpha, ...
    position_matrix, CellUncertainty);

HopperWeight_A = HopperWeight(:,1:HA);
HopperWeight_B = HopperWeight(:,HA+1:HA+HB);
HopperWeight_C = HopperWeight(:,HA+HB+1:HA+HB+HC);

UncertainWeight_A = UncertainWeight(:,1:HA);
UncertainWeight_B = UncertainWeight(:,HA+1:HA+HB);
UncertainWeight_C = UncertainWeight(:,HA+HB+1:HA+HB+HC);

W_best_tot = zeros(nComb, nSim);
W_best_ABC = zeros(nComb, 3, nSim);

for ii=1:nSim

    W_A = HopperWeight_A * CombinantionMatrix_A_Transp;
    W_B = HopperWeight_B * CombinantionMatrix_B_Transp;
    W_C = HopperWeight_C * CombinantionMatrix_C_Transp;

    W_Unc_A = UncertainWeight_A * CombinantionMatrix_A_Transp;
    W_Unc_B = UncertainWeight_B * CombinantionMatrix_B_Transp;
    W_Unc_C = UncertainWeight_C * CombinantionMatrix_C_Transp;

    [~,comb_A] = min(abs(W_Unc_A - WT_A),[],2);
    [~,comb_B] = min(abs(W_Unc_B - WT_B),[],2);
    [~,comb_C] = min(abs(W_Unc_C - WT_C),[],2);

    W_best_A = W_A(sub2ind_mod(size(W_A),1:size(W_A,1),comb_A.')).';
    W_best_B = W_B(sub2ind_mod(size(W_B),1:size(W_B,1),comb_B.')).';
    W_best_C = W_C(sub2ind_mod(size(W_C),1:size(W_C,1),comb_C.')).';

    W_best_ABC(:,:,ii) = [W_best_A W_best_B W_best_C];
    W_best_tot(:,ii) = sum(W_best_ABC(:,:,ii),2);

    [HopperWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
A UncertainWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
A] = Weight(nComb, HA, alpha, ...
        position_matrix(:,1:HA), CellUncertainty);
    [HopperWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
B UncertainWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
B] = Weight(nComb, HB, alpha, ...
        position_matrix(:,HA+1:HA+HB), CellUncertainty);
    [HopperWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
C UncertainWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
C] = Weight(nComb, HC, alpha, ...
        position_matrix(:,HA+HB+1:HA+HB+HC), CellUncertainty);

    idx = CombinantionMatrix_A(comb_A,:)~=0;
    HopperWeight_A(idx) = HopperWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
A(idx);
    UncertainWeight_A(idx) = UncertainWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
A(idx);
    idx = CombinantionMatrix_B(comb_B,:)~=0;
    HopperWeight_B(idx) = HopperWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
B(idx);
    UncertainWeight_B(idx) = UncertainWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
B(idx);
    idx = CombinantionMatrix_C(comb_C,:)~=0;
    HopperWeight_C(idx) = HopperWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
C(idx);
    UncertainWeight_C(idx) = UncertainWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
C(idx);

    clear HopperWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
A HopperWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
B HopperWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
C ...
        UncertainWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
A UncertainWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
B UncertainWeightfunction [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end
C;

end


n_b = logical(W_best_tot >= WL);
n_bA = logical(reshape(W_best_ABC(:,1,:), nComb, nSim) >= WL_A);
n_bB = logical(reshape(W_best_ABC(:,2,:), nComb, nSim) >= WL_B);
n_bC = logical(reshape(W_best_ABC(:,3,:), nComb, nSim) >= WL_C);

n_b_global = sum(n_b .* n_bA .* n_bB .* n_bC, 2);

GAvg_A  = sum(reshape(W_best_ABC(:,1,:), nComb, nSim).*(reshape(...
            W_best_ABC(:,1,:), nComb, nSim) > WT_A),2)./sum(reshape(...
            W_best_ABC(:,1,:), nComb, nSim) > WT_A,2);
GAvg_B  = sum(reshape(W_best_ABC(:,2,:), nComb, nSim).*(reshape(...
            W_best_ABC(:,2,:), nComb, nSim) > WT_B),2)./sum(reshape(...
            W_best_ABC(:,2,:), nComb, nSim) > WT_B,2);
GAvg_C  = sum(reshape(W_best_ABC(:,3,:), nComb, nSim).*(reshape(...
            W_best_ABC(:,3,:), nComb, nSim) > WT_C),2)./sum(reshape(...
            W_best_ABC(:,3,:), nComb, nSim) > WT_C,2);

f = Cu_A .* GAvg_A + Cu_B .* GAvg_B + Cu_C .* GAvg_C + (nSim./...
        n_b_global) .* c_p + (c_f./n_b_global) + ((nSim - n_b_global)./...
        n_b_global) .* c_l;

Function = f;

Профайлер

Это основной профайлер, а это: функция MHW и Функция веса. Основные проблемы связаны с весом, поскольку он вызывается 3000 раз для каждого поколения GA... Над кодом функции веса:

Код функции веса

function [ HopperWeight UncertainWeight ] = Weight( nComb, H, alpha, AllComb, CellUncertainty )

HopperWeight = randn(nComb,H) * alpha;
HopperWeight = (1+HopperWeight) .* AllComb;
idx = HopperWeight<0;
random = randn(sum(idx(:)), 1);
HopperWeight(idx) = random .* ((1+alpha) .* AllComb(idx));

%ADD ERROR
RandomizeUncertainty = randn(nComb,H) * CellUncertainty;
UncertainWeight = abs((1+RandomizeUncertainty) .* HopperWeight);
end

Есть ли что-то, чего мне не хватает, чтобы лучше оптимизировать функцию веса и вообще трудоемкую часть функции MHW? (Если вам нужна программа запуска GA, чтобы попробовать функцию MHW, используйте ЭТОТ код)

ТИА

gmeroni 24.06.2014 источник

comment

Я не уверен, что проблема с установкой так хорошо известна, вероятно, существует бесчисленное множество проблем с установкой. Но по результатам вашего профилирования я вижу, что вы провели много времени в sub2ind. Не уверен, что ваш код действительно нуждается в этом. Также функции вызываются много раз (200 000 раз). Возможно, некоторые из этих вызовов можно векторизовать. - Trilarion 24.06.2014

comment

@Trilarion Кто знает машину MHW, очень хорошо знает проблему установки :). Да, sub2ind занимает очень много времени, но я не знаю, как заменить его на что-то лучше (я сделал sub2ind без проверки ошибок, но результат тот же). Я уже включил опцию векторизации в GA. - gmeroni 24.06.2014

Оптимизация операций с матрицами

Код

Профайлер

Код функции веса

Похожие вопросы