% Construction d'un réseau de neurones

% Les entrées et cibles
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
cible=sortie;
cible_seq=con2seq(cible);

% si tout est dans le même vecteur :
entree=entree_ens;
entree_seq=con2seq(entree);

% Sinon :
% entree=entree_1;
% entree_seq=con2seq(entree);
% entree_2=entree_comp_1;
% entree_2_seq=con2seq(entree_2);
% entree_seq=[entree_seq;entree_2_seq];


% % Les entrées validation
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% entree_v=entree_1(:,end-nb_val-nb_test-1:end-nb_test);
% entree_2_v=entree_comp(:,end-nb_val-nb_test-1:end-nb_test);
% % entree_v=[entree_v;entree_2_v];
% cible_v=sortie(end-nb_val-nb_test-1:end-nb_test);
% entree_seq_v=con2seq(entree_v);
% entree_2_seq_v=con2seq(entree_2_v);
% val.P=[entree_seq_v;entree_2_seq_v];
% val.T=con2seq(cible_v);

% Les entrées tests
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
cible_t=sortie_test;
cible_seq_t=con2seq(cible_t);

% si tout est dans le même vecteur :
entree_t=entree_test_ens;
entree_seq_t=con2seq(entree_t);

% Sinon :
% entree_t=entree_test;
% entree_seq_t=con2seq(entree_t);
% entree_2_t=entree_comp_test;
% entree_2_seq_t=con2seq(entree_2_t);
% entree_seq_t=[entree_seq_t;entree_2_seq_t];


% Ouverture d'un réseau vierge et idenfication
mynet=network;

% Nombre de vecteurs d'entrée et nombre de couches totales
mynet.numInputs = 1;
mynet.numLayers = 3;

% Connexions de biais pour chaque couche et initialisation
mynet.biasConnect = [1; 1; 1];% ; 1; 1; 1
% mynet.biases{1}.initFcn='rands';
% mynet.biases{2}.initFcn='rands';
% mynet.biases{1}.learnFcn='learngdm';
% mynet.biases{2}.learnFcn='learngdm';

% Connexions des couches aux vecteurs d'entrée et initialisation
mynet.inputConnect = [1;0;0]; %1 1;0 0; 0 0;
% mynet.inputWeights{1,1}.initFcn='rands';
% mynet.inputWeights{1,2}.initFcn='rands';
% mynet.inputWeights{1,1}.learnFcn='learngdm';
% mynet.inputWeights{1,2}.learnFcn='learngdm';

% Connexions des couches entre elles et initialisation
mynet.layerConnect = [0 0 0;1 0 0;0 1 0];% [0 0 0 0 0; 0 0 0 0 0;1 1 0 0 0; 1 1 0 0 0;0 0 1 1 0];
% mynet.layerWeights{2,1}.initFcn='rands';
% mynet.layerWeights{2,1}.learnFcn='learngdm';

% Connexions des couches à la sortie du réseau et au vecteur cible
mynet.outputConnect = [0 0 1];%0 0 0
mynet.targetConnect = [0 0 1];% 0 0 0

% Définition des entreés
% Intervalle de variation au cours du temps de chaque composante du vecteur d'entrée
% entree=mapminmax(entree);
inter=zeros(size(entree,1),2);
for i=1:size(entree,1)
    inter(i,:)=[min(entree(i,:)) max(entree(i,:))];
end;
mynet.inputs{1}.range = inter;

% inter_2=zeros(size(entree_2,1),2);
% for i=1:size(entree_2,1)
%     inter_2(i,:)=[min(entree_2(i,:)) max(entree_2(i,:))];
% end;
% mynet.inputs{2}.range = inter_2;

% Définition des couches
% Nombre de neurones, fonction de transfert, initialisation
mynet.layers{1}.size=10;
mynet.layers{1}.transferFcn='tansig';
mynet.layers{1}.initFcn = 'initnw';

mynet.layers{2}.size=10;
mynet.layers{2}.transferFcn='tansig';
mynet.layers{2}.initFcn = 'initnw';

% mynet.layers{3}.size=5;
% mynet.layers{3}.transferFcn='logsig';
% mynet.layers{3}.initFcn = 'initnw';
%
% mynet.layers{4}.size=5;
% mynet.layers{4}.transferFcn='logsig';
% mynet.layers{4}.initFcn = 'initnw';
%
% mynet.layers{5}.transferFcn='logsig';
% mynet.layers{5}.initFcn = 'initnw';

% récurrence des entrées et des couches
% mynet.inputweights{1,1}.delays=0:2;

% mynet.inputweights{1,2}.delays=0:1;

% mynet.layerweights{1,1}.delays=1;
% mynet.layerweights{2,9}.delays=1;
% mynet.layerweights{3,9}.delays=1;
% mynet.layerweights{4,9}.delays=1;

% Paramètres du réseau
% Algo d'initialisation, fonction de performance et algo d'apprentissage
mynet.initFcn = 'initlay';
mynet.performFcn = 'mse';
mynet.trainFcn = 'traingdm';
%
% % Paramètres de l'algo d'apprentissage
mynet.trainParam.goal=1e-4;
mynet.trainParam.epochs=20000;
mynet.trainParam.show=NaN;
mynet.trainParam.mc=0.5;

% Initialisation
mynet = init(mynet);
mynet = train(mynet,entree_seq,cible_seq);%,[],[],val

n_out=sim(mynet,entree_seq);
n_out=cell2mat(n_out);
diff=sign(n_out)-sign(cible);
signe=1-nnz(diff)/(size(diff,2));
diff2=sign(n_out(2:end)-cible(1:end-1))-sign(cible(2:end)-cible(1:end-1));
direc=1-nnz(diff2)/(size(diff2,2));
diff3=sign(n_out(2:end)-n_out(1:end-1))-sign(cible(2:end)-cible(1:end-1));
direc_pred=1-nnz(diff3)/(size(diff3,2));
diff4=n_out-cible;
direc_unit=1-nnz(diff4)/(size(diff4,2));

% Test
n_out_t=sim(mynet,entree_seq_t);
n_out_t=cell2mat(n_out_t);
diff_t=sign(n_out_t)-sign(cible_t);
signe_t=1-nnz(diff_t)/(size(diff_t,2));
diff2_t=sign(n_out_t(2:end)-cible_t(1:end-1))-sign(cible_t(2:end)-cible_t(1:end-1));
direc_t=1-nnz(diff2_t)/(size(diff2_t,2));
diff3_t=sign(n_out_t(2:end)-n_out_t(1:end-1))-sign(cible_t(2:end)-cible_t(1:end-1));
direc_pred_t=1-nnz(diff3_t)/(size(diff3_t,2));
diff4_t=n_out_t-cible_t;

direc_unit_t=1-nnz(diff4_t)/(size(diff4_t,2));
save('essai_1');


hold off;
plot([n_out n_out_t]);
hold on;
plot([cible cible_t],'r');



