Matlab/Octave con EC2

Question

Mi piacerebbe utilizzare Matlab con EC2, è fondamentalmente un imbarazzante problema parallelo quindi non ho necessariamente bisogno della casella degli strumenti parallela.

Leggendo il blog qui:

http://aws.typepad.com/aws/2008/11/parallel-comput.html

Il link alla carta bianca, in realtà vi porta a una pagina web in cui si dice che il servizio è disponibile solo in USA e Canada (sono sede nel Regno Unito) ma puoi registrare il tuo interesse.

Inoltre sembra che ci possa essere un problema con le licenze? Se devo comprare una nuova licenza per ogni CPU, non è un buon inizio per me.

Il mio programma in realtà non usa nessuna grande funzione MATLAB come lsqmin, quindi in teoria dovrebbe essere facilmente convertibile in Octave (credo).

Se utilizzare Matlab con EC2 non è possibile per nessuno dei motivi sopra elencati qualcuno può dirmi come usare Octave con EC2?

function [output]=DElambda(de,data,OF) 

P1=zeros(de.d,de.nP); 
Pu=zeros(de.d,de.nP); 

for i=1:de.d 
P1(i,:)=de.min(i,1)+(de.max(i,1)-de.min(i,1))*rand(de.nP,1); 
end 


P1(:,1:de.d)=diag(de.max); 
P1(:,de.d+1:2*de.d)=diag(de.min); 


for i=1:de.nP 
betas(:,i)=NSS_betas(P1(:,i),data); 
end 

Params=vertcat(betas,P1); 

Fbv=NaN(de.nG,1); 
Fbest=realmax; 



F=zeros(de.nP,1); 
P=zeros(de.nP,1); 


for i=1:de.nP 

F(i)=OF(Params(:,i)',data); 

P(i)=pen(P1(:,i),de,F(i)); 
F(i)=F(i)+P(i); 


end 

[Fbest indice] =min(F); 
xbest=Params(:,indice); 


Col=1:de.nP; 

for g=1:de.nG 
P0=P1; 
rowS=randperm(de.nP)'; 
colS=randperm(4)'; 
RS=circshift(rowS,colS(1)); 
R1=circshift(rowS,colS(2)); 
R2=circshift(rowS,colS(3)); 
R3=circshift(rowS,colS(4)); 

%mutate 
Pm=P0(:,R1)+de.F*(P0(:,R2)-P0(:,R3)); 
%extra mutation 
if de.R>0 
    Pm=Pm+de.r*randn(de.d,de.nP); 
end 

%crossover 
PmElements=rand(de.d,de.nP)<de.CR; 
%mPv(MI)=mP(Mi); 
if de.oneElementfromPm 
    Row=unidrnd(de.d,1,de.nP); 
    ExtraPmElements=sparse(Row,Col,1,de.d,de.nP); 
    PmElements=PmElements|ExtraPmElements; 
end 

P0_Elements=~PmElements; 
Pu(:,RS)=P0(:,RS).*P0_Elements+PmElements.*Pm; 
%%%need to add penalty!!!!!!!!!!!! 
%select vector to enter next generation 

for i=1:de.nP 
betasPu(:,i)=NSS_betas(Pu(:,i),data); 
end 



ParamsPu=vertcat(betasPu,Pu); 
flag=0; 
for i=1:de.nP 
    %for j=1:dates 
    %Ftemp=feval(OF,Pu(:,i)',data,j); 
    Ftemp=OF(ParamsPu(:,i)',data); 
    %end 
    %Ftemp=OF(Pu(:,i),data); 
    Ptemp=pen(Pu(:,i),de,F(i)); 
    Ftemp=Ftemp+Ptemp; 

    if Ftemp<=F(i); 
     P1(:,i)=Pu(:,i); 
     F(i)=Ftemp; 
     if Ftemp < Fbest 
     Fbest=Ftemp; xbest=ParamsPu(:,i); flag=1; 
     end 
    else 
     P1(:,i)=P0(:,i); 
    end  
end 

if flag 
    Fbv(g)=Fbest; 
end 

end 

output.Fbest=Fbest; output.xbest=xbest; output.Fbv=Fbv; 
end 



function penVal=pen(mP,pso,vF) 

minV=pso.min; 
maxV=pso.max; 
ww=pso.ww; 

A=mP-maxV; 
A=A+abs(A); 

B=minV-mP; 
B=B+abs(B); 

C=ww*((mP(1,:)+mP(2,:))-abs(mP(1,:)+mP(2,:))); 
penVal=ww*sum(A+B,1)*vF-C; 


end 

Answer 1

Un'idea che non richiede licenze aggiuntive sarebbe quello di distribuire il MATLAB Compiler Runtime (MCR) sulle istanze EC2. Quindi utilizzare MATLAB Compiler per creare file eseguibili del codice ed eseguirli su tali istanze EC2.

L'MCR è fornito con Compilatore MATLAB per la distribuzione con l'applicazione e può essere distribuito senza royalty.

Se si desidera adottare ulteriormente questo approccio, prendere in considerazione l'esecuzione di una coda di lavoro locale che distribuisce il lavoro tra le istanze EC2 disponibili. This sembra essere una bella recensione su come farlo.