From 44ed4ce73e4b6dd397ec39160dd60399281ea1e3 Mon Sep 17 00:00:00 2001
From: Adeline Paiement <adeline.paiement@lis-lab.fr>
Date: Tue, 13 Jun 2023 10:41:37 +0200
Subject: [PATCH] Clean and simplify Interface.m
---
parmorceauxMax-git/Interface.m | 241 +++------------------------------
1 file changed, 18 insertions(+), 223 deletions(-)
diff --git a/parmorceauxMax-git/Interface.m b/parmorceauxMax-git/Interface.m
index 7b08017..bfdc3cf 100644
--- a/parmorceauxMax-git/Interface.m
+++ b/parmorceauxMax-git/Interface.m
@@ -6,19 +6,17 @@ classdef Interface < handle
N
%% résultats en sortie
- meilleure_sequence
- meilleure_sequence_models
loglikelihood
%% modèle statistique
interpolant_filename
- %% morceaux courants (cad non finis) A, B1, B2 et C
- dynamics_models
- first_frame_of_models
+ %% modèle courant
+ dynamics_model
+ proba_model % probabilité courante pour le modèle
%% paramètres de la méthode
- initial_alphas
+ initial_alpha
sigma_estimation
sigma_test
@@ -27,95 +25,45 @@ classdef Interface < handle
display_screen
- %% Viterbi
- transition
-
- proba_morceaux % probabilité courante pour chaque morceau, avec son meilleur path Viterbi
- morceaux_finis % pour chaque morceau courant : liste des morceaux finis du path. Cette liste contient une copie du morceau dans l'état où il était quand il a été terminé
- proba_morceaux_finis % pour chaque morceau courant : liste des probabilités associées aux morceaux finis. Elle combine la proba de chaque observation du morceau et la proba de transition du morceau au suivant
-
- model_indexes % pour chaque morceau courant : liste des indices des morceaux du path Viterbi pour chaque frame
- scores_finis % pour chaque morceau courant : liste des proba d'observation pour chaque frame (uniquement les frames des morceaux finis, car le morceau courant n'est pas encore stable et les x peuvent encore changer)
-
end
methods
function obj = Interface(interpolant_filename, display_screen)
obj.interpolant_filename = interpolant_filename;
-
- obj.transition = [ 0.5 0.5 0 0; % départ de A
- 0 1/3 1/3 1/3; % départ de B1
- 0 0 0.5 0.5; % départ de B2
- 0 0 0 1 % départ de C
- ];
-
obj.display_screen = display_screen;
end
- function process_new_sequence(obj, filename, initial_alphas, sigma_estimation, sigma_test, threshold_dynamics)
+ function process_new_sequence(obj, filename, initial_alpha, sigma_estimation, sigma_test, threshold_dynamics)
obj.threshold_dynamics = threshold_dynamics;
- obj.dynamics_models = {NaN, NaN, NaN, NaN}; % modèles courants A B1 B2 et C
- obj.first_frame_of_models = [1 NaN NaN NaN]; % frame où chaque modèle commence
+ obj.dynamics_model = NaN; % modèle courant
if obj.display_screen == -1
- obj.dynamics_models = Dynamics_Model(obj.interpolant_filename, obj.display_screen);
+ obj.dynamics_model = Dynamics_Model(obj.interpolant_filename, obj.display_screen);
else
- obj.dynamics_models = Dynamics_Model(obj.interpolant_filename, obj.display_screen+1);
+ obj.dynamics_model = Dynamics_Model(obj.interpolant_filename, obj.display_screen+1);
end
- obj.proba_morceaux = [1 0 0 0]; % proba des modèles A, B1, B2, et C
+ obj.proba_model = 1;
obj.T = [];
obj.Y = [];
obj.N = [];
- obj.scores_finis = {[], [], [], []};
- obj.model_indexes = {[], [], [], []};
-
- obj.initial_alphas = initial_alphas;
+ obj.initial_alpha = initial_alpha;
obj.sigma_estimation = sigma_estimation;
obj.sigma_test = sigma_test;
- obj.morceaux_finis = {[], [], [], []};
- obj.proba_morceaux_finis = {[], [], [], []};
-
obj.read_data(filename);
- obj.N = 25;
-
- obj.dynamics_models.initialise(0, initial_alphas, sigma_estimation, sigma_test,obj.Y,obj.T);
- %ligne 14
- % for frame=1:25
-% obj.process_frame(frame);
- obj.dynamics_models.spread_X();
-% if obj.display_screen ~= -1
-% for model=1:4
-% if obj.proba_morceaux(model) == 0 || isnan(obj.proba_morceaux(model))
-% continue
-% end
-% obj.dynamics_models{model}.plot_estimated_X();
-% end
-% end
- %end
+ obj.dynamics_model.initialise(0, initial_alpha, sigma_estimation, sigma_test,obj.Y,obj.T);
-% %% choix de la meilleure sequence (peut être pour plus tard: toujours choisir la séquence qui se termine sur le modèle C ?)
-% [max_proba, indice] = max(obj.proba_morceaux);
-% obj.meilleure_sequence = obj.model_indexes{indice}
-% obj.meilleure_sequence_models = [obj.morceaux_finis{indice} obj.dynamics_models{indice}];
+ obj.dynamics_model.spread_X();
+
+ new_scores = obj.dynamics_model.compute_loglikelihood_dynamics([1:obj.N]);
+ obj.loglikelihood = new_scores;
-% %% calcul les scores pour les frames du dernier morceau
-% % mise à jour des x pour bien les étaler
-% obj.meilleure_sequence_models(end).spread_X();
-% new_scores = obj.meilleure_sequence_models(end).compute_loglikelihood_dynamics([1:obj.N-obj.first_frame_of_models(indice)+1]);
-% obj.loglikelihood = [obj.scores_finis{indice} new_scores];
-%
-% %% à faire : afficher la séquence des modèles et la séquence de scores comme dans plot
-% close all
-% for i=1:length(obj.meilleure_sequence_models)
-% obj.meilleure_sequence_models(i).plot_estimated_X();
-% end
-%%% save plot
- % obj.dynamics_models.plot_estimated_X( filename(end-9:end-4) );
+ close all
+ obj.dynamics_model.plot_estimated_X();
end
function read_data(obj, filename)
obj.Y =load(filename);
@@ -124,160 +72,7 @@ classdef Interface < handle
%obj.Y = repmat(obj.Y, 3, 1);
obj.T = [1:25]';
obj.Y = obj.Y / max(obj.Y);
- end
- function process_frame(obj, frame_number)
-
- frame_number
-
- Yt = obj.Y(frame_number,:);
- Tt = obj.T(frame_number);
-
- %% tableaux temporaires dans lesquels on prépare la prochaine version des tableaux de la classe sans les modifier avant d'avoir terminé de traiter la frame pour tous les morceaux
- new_proba_morceaux = [NaN NaN NaN NaN];
- new_morceaux_finis = {[], [], [], []};
- new_proba_morceaux_finis = {[], [], [], []};
-
- new_models = {NaN, NaN, NaN, NaN};
- new_first_frame_of_models = [NaN NaN NaN NaN];
-
- new_scores_finis = {[], [], [], []};
- new_model_indexes = {[], [], [], []};
-
-
- %% boucle sur les 4 modèles possibles
- for morceau = 1:4
-
- % on va regarder toutes les branches qui arrivent sur le modèle
-
- %% tableaux temporaires pour le morceau courant et toutes les branches possibles
- modele_branche = {NaN, NaN, NaN, NaN}; % copie des modèles pour leur montrer la nouvelle frame, sans modifier ceux de obj.dynamics_models
- first_frame_of_model_branche = [NaN NaN NaN NaN]; % pour les copies des modèles
- proba_obs_branche = [NaN NaN NaN NaN]; % proba d'observation donnée par les copies des modèles ayant vu la frame courante
- nouveau_morceau_fini_branche = {NaN, NaN, NaN, NaN}; % si une branche implique un nouveau morceau fini, on le sauvegarde ici en attendant Viterbi et le choix de la branche (cad si on le garde ou pas)
- proba_branche = [NaN NaN NaN NaN]; % proba totale de chaque branche
- proba_morceau_prec = [NaN NaN NaN NaN]; % proba totale des frames vues par le morceau qui était courant à la frame précédente (donc d'indice=branche). Ces proba sont combinées avec les probas de transition au sein du morceau
- new_scores_branche = {[] [] [] []}; % score des frames vues par le morceau qui était courant à la frame précédente
-
- if frame_number == 1
- if obj.proba_morceaux(morceau) == 0
- continue
- end
-
- new_models{morceau} = copy(obj.dynamics_models{morceau});
- new_first_frame_of_models(morceau) = obj.first_frame_of_models(morceau);
-
- new_models{morceau}.process_new_frame(Yt, Tt);
- proba_obs = new_models{morceau}.compute_loglikelihood_dynamics(1);
-
- new_proba_morceaux(morceau) = log(obj.proba_morceaux(morceau)) + proba_obs;
- new_morceaux_finis{morceau} = [];
-
- new_model_indexes{morceau} = [morceau];
- else
- %% on calcule les probas de toutes les branches qui arrivent sur le morceau courant
- for branche = 1:4
- trans = obj.transition(branche, morceau);
-
- % on commence par ignorer les branches impossibles
- if trans == 0
- continue
- end
- if obj.proba_morceaux(branche) == 0 || isnan(obj.proba_morceaux(branche))
- continue
- end
-
- if branche == morceau % cas sans changement de modèle, donc le modèle est déjà initialisé
- modele_branche{branche} = copy(obj.dynamics_models{branche});
- first_frame_of_model_branche(branche) = obj.first_frame_of_models(morceau);
- else % cas avec changement de modèle, donc il faut créer et initialiser le modèle
- %% on crée le modèle et on l'initialise
- if obj.display_screen == -1
- modele_branche{branche} = Dynamics_Model(obj.interpolant_filenames{morceau}, obj.display_screen);
- else
- modele_branche{branche} = Dynamics_Model(obj.interpolant_filenames{morceau}, obj.display_screen+morceau);
- end
- modele_branche{branche}.initialise(0, obj.initial_alphas(morceau), obj.sigma_estimation, obj.sigma_test);
- %modele_branche{branche}.initialise(0, obj.dynamics_models{branche}.current_alpha, obj.sigma_estimation, obj.sigma_test);
- first_frame_of_model_branche(branche) = frame_number;
- end
-
- %% on donne la frame au modèle, et on récupère la proba d'observation (dans la fenêtre)
- modele_branche{branche}.process_new_frame(Yt, Tt);
- %print branche et morceau
- BRANCHE=branche
- MORCEAU=morceau
- proba_obs_branche(branche) = modele_branche{branche}.compute_loglikelihood_dynamics(frame_number-first_frame_of_model_branche(branche)+1);
-
- %% on garde en mémoire les morceaux qui sont finis, pour l'affichage final des X
-%%%% %%%%%%%%%%%%%%%% a faire : mettre à jour les x pour bien les étaler
- if branche == morceau
- nouveau_morceau_fini_branche{branche} = 0;
- else
- nouveau_morceau_fini_branche{branche} = copy(obj.dynamics_models{branche}); % ce modèle n'a pas encore vu la frame courante, on peut donc le sauvegader dans son état à la frame précédente
-%%%% %%%%%% mettre à jour la copie ici
- nouveau_morceau_fini_branche{branche}.spread_X();
- end
-
- %% on récupère les scores des frames vues par le modèle
- if branche == morceau
- %% on récupère les scores pour les frames précédentes, qui ont pu bouger avec le argmax
- proba_morceau_prec(branche) = sum(modele_branche{branche}.compute_loglikelihood_dynamics([1:frame_number-first_frame_of_model_branche(branche)]));
- proba_morceau_prec(branche) = proba_morceau_prec(branche) + log(trans) * (frame_number-first_frame_of_model_branche(branche)-1);
- else
- %% on récupère les scores pour les frames précédentes, qui ont pu bouger avec le argmax
- new_scores_branche{branche} = nouveau_morceau_fini_branche{branche}.compute_loglikelihood_dynamics([1:frame_number-obj.first_frame_of_models(branche)]);
- proba_morceau_prec(branche) = sum(new_scores_branche{branche});
- trans_morceau_prec = obj.transition(branche, branche);
- proba_morceau_prec(branche) = proba_morceau_prec(branche) + log(trans_morceau_prec) * (frame_number-obj.first_frame_of_models(branche)-1);
- end
-
- proba_branche(branche) = sum(obj.proba_morceaux_finis{branche}) + proba_morceau_prec(branche) + log(trans) + proba_obs_branche(branche);
- end
-
- %% on choisi la meilleure branche
- [max_val, indice] = max(proba_branche);
-
- if isnan(max_val)
- continue
- end
-
- new_proba_morceaux(morceau) = max_val;
-
- new_models{morceau} = modele_branche{indice};
- new_first_frame_of_models(morceau) = first_frame_of_model_branche(indice);
-
- if nouveau_morceau_fini_branche{indice} ~= 0
- new_morceaux_finis{morceau} = [obj.morceaux_finis{indice} nouveau_morceau_fini_branche{indice}];
- trans = obj.transition(indice, morceau);
- new_proba_morceaux_finis{morceau} = [obj.proba_morceaux_finis{indice} proba_morceau_prec(indice) + log(trans)];
- new_scores_finis{morceau} = [obj.scores_finis{indice} new_scores_branche{indice}];
- else
- new_morceaux_finis{morceau} = obj.morceaux_finis{indice};
- new_proba_morceaux_finis{morceau} = obj.proba_morceaux_finis{indice};
- new_scores_finis{morceau} = obj.scores_finis{indice};
- end
-
- new_model_indexes{morceau} = [obj.model_indexes{indice} morceau];
- end
- end
-
- obj.proba_morceaux = new_proba_morceaux;
- obj.dynamics_models = new_models;
- obj.first_frame_of_models = new_first_frame_of_models;
-
- obj.scores_finis = new_scores_finis;
-
- obj.morceaux_finis = new_morceaux_finis;
- obj.proba_morceaux_finis = new_proba_morceaux_finis;
-
- obj.model_indexes = new_model_indexes;
-
-
- %% réflexions pour plus tard
- %% gérer : alpha différents pour les différents modèles (alpha_ini + marges)
- %% fin des modèles : duppliquer les dernières colonnes pour que x ait le temps de se fixer ? (avec pénalité lors de la comparaison des modèles)
- %% ou alors : on n'attend pas que les x soient stables
- %% initialiser le modèle concurrent à chaque fois (tant qu'on n'a pas basculé dessus)
+ obj.N = 25;
end
function plot(obj) %% cette fonction est à modifier car maintenant nous avons plusieurs modèles / morceaux
obj.dynamics_model.plot_estimated_X();
--
GitLab