ENSEEIHT/TP-traitement-audio-visuel
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

init

Browse source
This commit is contained in:
Laureηt 2023-06-22 20:47:16 +02:00
commit fc4598e9b5
Signed by: Laurent
SSH key fingerprint: SHA256:kZEpW8cMJ54PDeCvOhzreNr4FSh6R13CMGH/POoO8DI
209 changed files with 13680 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
TP1/bezier.m Normal file
View file

@ -0,0 +1,7 @@
function y = bezier(beta_0,beta,beta_d,x)
d = length(beta)+1;
y = beta_0*(1-x).^d+beta_d*x.^d;
for i = 1:d-1
y = y+beta(i)*nchoosek(d,i)*x.^i.*(1-x).^(d-i);
end
end

3
TP1/bezier_bruitee.m Normal file
View file

@ -0,0 +1,3 @@
function y = bezier_bruitee(beta_0,beta,beta_d,x,sigma)
y = bezier(beta_0,beta,beta_d,x)+sigma*randn(size(x));
end

16
TP1/calcul_VC.m Normal file
View file

@ -0,0 +1,16 @@
function VC = calcul_VC(D_app, beta_0, beta_d, d)
X = D_app(1,:)';
Y = D_app(2,:)';
n = length(X);
VC = 0;
for j=1:n
D_app_loo = [D_app(:,1:j-1) , D_app(:,j+1:n)];
beta = moindres_carres(D_app_loo, beta_0, beta_d, d);
estimation = bezier(beta_0, beta, beta_d, X(j));
VC = VC + (Y(j) - estimation).^2;
end
VC = VC/n;
end

34
TP1/donnees_apprentissage.m Executable file
View file

@ -0,0 +1,34 @@
clear;
close all;
taille_ecran = get(0,'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
% Calcul du mod<EFBFBD>le exact :
beta_0 = 115;
beta_d = 123;
beta = [133,96,139,118];
n_affichage = 200; % Utilisation de 200 points pour l'affichage
pas_affichage = 1/(n_affichage-1);
x = 0:pas_affichage:1;
y = bezier(beta_0,beta,beta_d,x);
% TracŽ du mod<EFBFBD>le exact (trait noir) :
figure('Name','Estimation de parametres','Position',[0.4*L,0.05*H,0.6*L,0.7*H]);
plot(x,y,'-k','LineWidth',2);
set(gca,'FontSize',20);
xlabel('$x$','Interpreter','Latex','FontSize',30);
ylabel('$y$','Interpreter','Latex','FontSize',30);
hold on;
% Calcul des donnŽes d'apprentissage (bruit blanc sur les ordonnŽes) :
n_app = 50;
pas_app = 1/(n_app-1);
x_j = 0:pas_app:1;
sigma = 0.5;
y_j = bezier_bruitee(beta_0,beta,beta_d,x_j,sigma);
D_app = [x_j ; y_j];
% TracŽ des donnŽes d'apprentissage (croix bleues) :
plot(x_j,y_j,'+b','MarkerSize',10,'LineWidth',3);
legend(' Modele exact',' Donnees d''apprentissage','Location','Best');

41
TP1/donnees_test.m Executable file
View file

@ -0,0 +1,41 @@
clear;
close all;
taille_ecran = get(0,'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
% Calcul du modèle exact :
beta_0 = 115;
beta_d = 123;
beta = [133,96,139,118];
n_affichage = 200; % Utilisation de 200 points pour l'affichage
pas_affichage = 1/(n_affichage-1);
x = 0:pas_affichage:1;
y = bezier(beta_0,beta,beta_d,x);
% Tracé du modèle exact (trait noir) :
figure('Name','Estimation de parametres','Position',[0.4*L,0.05*H,0.6*L,0.7*H]);
plot(x,y,'-k','LineWidth',2);
set(gca,'FontSize',20);
xlabel('$x$','Interpreter','Latex','FontSize',30);
ylabel('$y$','Interpreter','Latex','FontSize',30);
hold on;
% Calcul des données d'apprentissage (bruit blanc sur les ordonnées) :
n_app = 50;
pas_app = 1/(n_app-1);
x_j = 0:pas_app:1;
sigma = 0.5;
y_j = bezier_bruitee(beta_0,beta,beta_d,x_j,sigma);
D_app = [x_j ; y_j];
% Calcul des données de test :
n_test = 200;
pas_test = 1/(n_test-1);
x_k = 0:pas_test:1;
y_k = bezier_bruitee(beta_0,beta,beta_d,x_k,sigma);
D_test = [x_k ; y_k];
% Tracé des données de test (croix vertes) :
plot(x_k,y_k,'+g','MarkerSize',10,'LineWidth',3);
legend(' Modele exact',' Donnees de test','Location','Best');

9
TP1/erreur_apprentissage.m Normal file
View file

@ -0,0 +1,9 @@
function erreur = erreur_apprentissage(D_app, beta_0, beta_d, d)
X = D_app(1, :)';
Y = D_app(2, :)';
beta = moindres_carres(D_app, beta_0, beta_d, d);
estimation = bezier(beta_0, beta, beta_d, X);
erreur = mean((estimation - Y).^2);
end

9
TP1/erreur_generalisation.m Normal file
View file

@ -0,0 +1,9 @@
function erreur = erreur_generalisation(D_test, D_app, beta_0, beta_d, d)
X = D_test(1, :)';
Y = D_test(2, :)';
beta = moindres_carres(D_app, beta_0, beta_d, d);
estimation = bezier(beta_0, beta, beta_d, X);
erreur = mean((estimation - Y).^2);
end

6
TP1/estimation_d_sigma.m Normal file
View file

@ -0,0 +1,6 @@
function [d_estime, sigma_estime] = estimation_d_sigma(liste_d, liste_erreurs_generalisation)
[~, index] = min(liste_erreurs_generalisation);
d_estime = liste_d(index);
sigma_estime = std(liste_erreurs_generalisation);
end

6
TP1/estimation_d_sigma_bis.m Normal file
View file

@ -0,0 +1,6 @@
function [d_estime,sigma_estime] = estimation_d_sigma_bis(liste_d,liste_VC)
[~, index] = min(liste_VC);
d_estime = liste_d(index);
sigma_estime = std(liste_VC);
end

26
TP1/exercice_1.m Executable file
View file

@ -0,0 +1,26 @@
% donnees_apprentissage;
donnees_test;
% % Degr<EFBFBD> de la courbe de B<EFBFBD>zier utilis<EFBFBD>e comme mod<EFBFBD>le (testez plusieurs valeurs de d entre 2 et 20) :
degres = 2:5:20;
%
% % Estimation des param<EFBFBD>tres de la courbe de B<EFBFBD>zier (sauf beta_0 et beta_d) :
% beta_estime = moindres_carres(D_app,beta_0,beta_d,d);
%
% % Trac<EFBFBD> de la courbe de B<EFBFBD>zier estim<EFBFBD>e, de degr<EFBFBD> d (trait rouge) :
% y_estime = bezier(beta_0,beta_estime,beta_d,x);
% plot(x,y_estime,'-r','MarkerSize',10,'LineWidth',3);
% lg = legend(' Modele exact',' Donnees d''apprentissage',[' Modele estime ($d=' num2str(d) '$)'],'Location','Best');
% set(lg,'Interpreter','Latex');
% for d=degres
% beta_estime = moindres_carres(D_app,beta_0,beta_d,d);
% y_estime = bezier(beta_0,beta_estime,beta_d,x);
% plot(x,y_estime,'MarkerSize',10,'LineWidth',3, 'DisplayName', ['d=',num2str(d)]);
% end
for d = degres
beta_estime = moindres_carres(D_test, beta_0, beta_d, d);
y_estime = bezier(beta_0, beta_estime, beta_d, x);
plot(x, y_estime, 'MarkerSize', 10, 'LineWidth', 3, 'DisplayName', ['d=', num2str(d)]);
end

27
TP1/exercice_2.m Executable file
View file

@ -0,0 +1,27 @@
% donnees_apprentissage;
donnees_test;
close all;
% Calcul de l'erreur d'apprentissage en fonction de d :
% liste_d = 2:length(D_app);
% liste_erreurs_apprentissage = [];
% for d = liste_d
% erreur = erreur_apprentissage(D_app,beta_0,beta_d,d);
% liste_erreurs_apprentissage = [liste_erreurs_apprentissage erreur];
% end
liste_d = 2:10:length(D_test);
liste_erreurs_apprentissage = [];
for d = liste_d
erreur = erreur_apprentissage(D_test, beta_0, beta_d, d);
liste_erreurs_apprentissage = [liste_erreurs_apprentissage erreur];
end
% Trac<EFBFBD> de l'erreur d'apprentissage en fonction de d :
figure('Name', 'Erreur d''apprentissage', 'Position', [0.4 * L, 0.05 * H, 0.6 * L, 0.7 * H]);
plot(liste_d, liste_erreurs_apprentissage, 'sb-', 'LineWidth', 2);
set(gca, 'FontSize', 20);
xlabel('$d$', 'Interpreter', 'Latex', 'FontSize', 30);
ylabel('Erreur', 'FontSize', 30);
legend(' Erreur d''apprentissage', 'Location', 'Best');

36
TP1/exercice_3.m Executable file
View file

@ -0,0 +1,36 @@
donnees_test;
close all;
% Calcul de l'erreur d'apprentissage (risque empirique) :
liste_d = 2:20;
liste_erreurs_apprentissage = [];
for d = liste_d
erreur = erreur_apprentissage(D_app, beta_0, beta_d, d);
liste_erreurs_apprentissage = [liste_erreurs_apprentissage erreur];
end
% Tracé de l'erreur d'apprentissage en fonction de d :
figure('Name', 'Erreur d''apprentissage et erreur de generalisation', 'Position', [0.4 * L, 0.05 * H, 0.6 * L, 0.7 * H]);
plot(liste_d, liste_erreurs_apprentissage, 'sb-', 'LineWidth', 2);
set(gca, 'FontSize', 20);
xlabel('$d$', 'Interpreter', 'Latex', 'FontSize', 30);
ylabel('Erreur', 'FontSize', 30);
hold on;
% Calcul de l'erreur de généralisation (risque espéré) :
liste_erreurs_generalisation = [];
for d = liste_d
erreur = erreur_generalisation(D_test, D_app, beta_0, beta_d, d);
liste_erreurs_generalisation = [liste_erreurs_generalisation erreur];
end
% Tracé de l'erreur de généralisation en fonction de d :
plot(liste_d, liste_erreurs_generalisation, 'sg-', 'LineWidth', 2);
legend(' Erreur d''apprentissage', ' Erreur de generalisation', 'Location', 'Best');
% Estimation du degré d et de l'écart-type sigma :
[d_estime, sigma_estime] = estimation_d_sigma(liste_d, liste_erreurs_generalisation);
fprintf('Estimation du degre : d = %d\n', d_estime);
fprintf('Estimation de l''ecart-type du bruit sur les donnees : %.3f\n', sigma_estime);

26
TP1/exercice_4.m Executable file
View file

@ -0,0 +1,26 @@
donnees_test;
close all;
% Calcul de la validation croisée Leave-one-out :
liste_d = 2:20;
liste_VC = [];
tic;
for d = liste_d
VC = calcul_VC(D_app, beta_0, beta_d, d);
liste_VC = [liste_VC VC];
end
toc;
% Tracé de la validation croisée Leave-one-out en fonction de d :
figure('Name', 'Validation croisee', 'Position', [0.4 * L, 0.05 * H, 0.6 * L, 0.7 * H]);
plot(liste_d, liste_VC, 'sr-', 'LineWidth', 2);
set(gca, 'FontSize', 20);
xlabel('$d$', 'Interpreter', 'Latex', 'FontSize', 30);
ylabel('$VC$', 'Interpreter', 'Latex', 'FontSize', 30);
% Estimation du degré d et de l'écart-type sigma :
[d_estime, sigma_estime] = estimation_d_sigma_bis(liste_d, liste_VC);
fprintf('Estimation du degre : d = %d\n', d_estime);
fprintf('Estimation de l''ecart-type du bruit sur les donnees : %.3f\n', sigma_estime);

29
TP1/exercice_5.m Normal file
View file

@ -0,0 +1,29 @@
clear;
close all;
% constantes
beta_0 = 115;
beta_d = 123;
beta = [133, 96, 139, 118];
n_app = 100;
pas_app = 1 / (n_app - 1);
x_j = 0:pas_app:1;
sigma = 0.5;
d = 5;
n = 10000;
beta_moyen = zeros(1, d - 1)';
sigma_moyen = 0;
for i = 1:n
% génération de nouveaux points d'apprentissage
y_j = bezier_bruitee(beta_0, beta, beta_d, x_j, sigma);
D_app = [x_j; y_j];
beta_estime = moindres_carres(D_app, beta_0, beta_d, d);
beta_moyen = beta_moyen + beta_estime / n;
end
[beta', beta_moyen]

14
TP1/moindres_carres.m Normal file
View file

@ -0,0 +1,14 @@
function estimation = moindres_carres(D_app, beta_0, beta_d, d)
X = D_app(1, :)';
Y = D_app(2, :)';
B = Y - beta_0 * (1 - X).^d - beta_d * (X.^d);
A = zeros(length(X), d - 1);
for i = 1:(d - 1)
A(:, i) = nchoosek(d, i) .* X.^i .* (1 - X).^(d - i);
end
estimation = A \ B;
end

386
TP1/rapport/rapport.html Normal file
View file

File diff suppressed because one or more lines are too long

313
TP1/rapport/rapport.md Normal file
View file

@ -0,0 +1,313 @@
---
author: Laurent Fainsin
title: TAV, TP1, LF
description: Rapport de Traitement des données audio-visuelles, Travail Pratique 1, Laurent Fainsin
---
# Fonctions auxilliaires
```matlab
function y = bezier(beta_0,beta,beta_d,x)
d = length(beta)+1;
y = beta_0 * (1-x).^d + beta_d * x.^d;
for i = 1:d-1
y = y + beta(i) * nchoosek(d,i) * x.^i .* (1-x).^(d-i);
end
end
```
```matlab
function y = bezier_bruitee(beta_0,beta,beta_d,x,sigma)
y = bezier(beta_0,beta,beta_d,x)+sigma*randn(size(x));
end
```
# Exercice 1
```matlab
function estimation = moindres_carres(D_app, beta_0, beta_d, d)
X = D_app(1,:)';
Y = D_app(2,:)';
B = Y - beta_0*(1-X).^d - beta_d*(X.^d);
A = zeros(length(X), d-1);
for i=1:(d-1)
A(:,i) = nchoosek(d, i) .* X.^i .* (1-X).^(d-i);
end
estimation = A \ B;
end
```
```matlab
donnees_apprentissage;
close all;
% DegrŽé de la courbe de BŽezier
d = 8;
% Estimation des paramètres de la courbe de BŽezier (sauf beta_0 et beta_d) :
beta_estime = moindres_carres(D_app,beta_0,beta_d,d);
% TracŽ de la courbe de BŽezier estimŽe, de degréŽ d (trait rouge) :
y_estime = bezier(beta_0,beta_estime,beta_d,x);
plot(x,y_estime,'-r','MarkerSize',10,'LineWidth',3);
lg = legend(' Modele exact',' Donnees d''apprentissage',[' Modele estime ($d=' num2str(d) '$)'],'Location','Best');
set(lg,'Interpreter','Latex');
```
<img src="exercice_1.svg">
# Exercice 2
```matlab
function erreur = erreur_apprentissage(D_app,beta_0,beta_d,d)
X = D_app(1,:)';
Y = D_app(2,:)';
beta = moindres_carres(D_app, beta_0, beta_d, d);
estimation = bezier(beta_0, beta, beta_d, X);
erreur = mean((estimation - Y).^2);
end
```
```matlab
donnees_apprentissage;
close all;
% Calcul de l'erreur d'apprentissage en fonction de d :
liste_d = 2:length(D_app);
liste_erreurs_apprentissage = [];
for d = liste_d
erreur = erreur_apprentissage(D_app,beta_0,beta_d,d);
liste_erreurs_apprentissage = [liste_erreurs_apprentissage erreur];
end
% TracŽ de l'erreur d'apprentissage en fonction de d :
figure('Name','Erreur d''apprentissage','Position',[0.4*L,0.05*H,0.6*L,0.7*H]);
plot(liste_d,liste_erreurs_apprentissage,'sb-','LineWidth',2);
set(gca,'FontSize',20);
xlabel('$d$','Interpreter','Latex','FontSize',30);
ylabel('Erreur','FontSize',30);
legend(' Erreur d''apprentissage','Location','Best');
```
<img src="exercice_2.svg">
# Données de test
## Exercice 1
```matlab
donnees_test;
% % DegrŽ de la courbe de BŽzier utilisŽe comme modle (testez plusieurs valeurs de d entre 2 et 20) :
degres = 2:5:20;
for d=degres
beta_estime = moindres_carres(D_test,beta_0,beta_d,d);
y_estime = bezier(beta_0,beta_estime,beta_d,x);
plot(x,y_estime,'MarkerSize',10,'LineWidth',3, 'DisplayName', ['d=',num2str(d)]);
end
```
<img src="exercice_1_test.svg">
## Exercice 2
```matlab
donnees_test;
close all;
liste_d = 2:10:length(D_test);
liste_erreurs_apprentissage = [];
for d = liste_d
erreur = erreur_apprentissage(D_test,beta_0,beta_d,d);
liste_erreurs_apprentissage = [liste_erreurs_apprentissage erreur];
end
% TracŽ de l'erreur d'apprentissage en fonction de d :
figure('Name','Erreur d''apprentissage','Position',[0.4*L,0.05*H,0.6*L,0.7*H]);
plot(liste_d,liste_erreurs_apprentissage,'sb-','LineWidth',2);
set(gca,'FontSize',20);
xlabel('$d$','Interpreter','Latex','FontSize',30);
ylabel('Erreur','FontSize',30);
legend(' Erreur d''apprentissage','Location','Best');
```
<img src="exercice_2_test.svg">
# Exercice 3
```matlab
function erreur = erreur_generalisation(D_test,D_app,beta_0,beta_d,d)
X = D_test(1,:)';
Y = D_test(2,:)';
beta = moindres_carres(D_app, beta_0, beta_d, d);
estimation = bezier(beta_0, beta, beta_d, X);
erreur = mean((estimation - Y).^2);
end
```
```matlab
function [d_estime, sigma_estime] = estimation_d_sigma(liste_d, liste_erreurs_generalisation)
[~, index] = min(liste_erreurs_generalisation);
d_estime = liste_d(index);
sigma_estime = std(liste_erreurs_generalisation);
end
```
```matlab
donnees_test;
close all;
% Calcul de l'erreur d'apprentissage (risque empirique) :
liste_d = 2:20;
liste_erreurs_apprentissage = [];
for d = liste_d
erreur = erreur_apprentissage(D_app,beta_0,beta_d,d);
liste_erreurs_apprentissage = [liste_erreurs_apprentissage erreur];
end
% Tracé de l'erreur d'apprentissage en fonction de d :
figure('Name','Erreur d''apprentissage et erreur de generalisation','Position',[0.4*L,0.05*H,0.6*L,0.7*H]);
plot(liste_d,liste_erreurs_apprentissage,'sb-','LineWidth',2);
set(gca,'FontSize',20);
xlabel('$d$','Interpreter','Latex','FontSize',30);
ylabel('Erreur','FontSize',30);
hold on;
% Calcul de l'erreur de généralisation (risque espéré) :
liste_erreurs_generalisation = [];
for d = liste_d
erreur = erreur_generalisation(D_test,D_app,beta_0,beta_d,d);
liste_erreurs_generalisation = [liste_erreurs_generalisation erreur];
end
% Tracé de l'erreur de généralisation en fonction de d :
plot(liste_d,liste_erreurs_generalisation,'sg-','LineWidth',2);
legend(' Erreur d''apprentissage',' Erreur de generalisation','Location','Best');
% Estimation du degré d et de l'écart-type sigma :
[d_estime,sigma_estime] = estimation_d_sigma(liste_d,liste_erreurs_generalisation);
fprintf('Estimation du degre : d = %d\n',d_estime);
fprintf('Estimation de l''ecart-type du bruit sur les donnees : %.3f\n',sigma_estime);
```
```
Estimation du degre : d = 5
Estimation de l'ecart-type du bruit sur les donnees : 0.477
```
<img src="exercice_3.svg">
# Exercice 4
```matlab
function VC = calcul_VC(D_app, beta_0, beta_d, d)
X = D_app(1,:)';
Y = D_app(2,:)';
n = length(X);
VC = 0;
for j=1:n
D_app_loo = [D_app(:,1:j-1) , D_app(:,j+1:n)];
beta = moindres_carres(D_app_loo, beta_0, beta_d, d);
estimation = bezier(beta_0, beta, beta_d, X(j));
VC = VC + (Y(j) - estimation).^2;
end
VC = VC/n;
end
```
```matlab
function [d_estime,sigma_estime] = estimation_d_sigma_bis(liste_d,liste_VC)
[~, index] = min(liste_VC);
d_estime = liste_d(index);
sigma_estime = std(liste_VC);
end
```
```matlab
donnees_test;
close all;
% Calcul de la validation croisée Leave-one-out :
liste_d = 2:20;
liste_VC = [];
tic;
for d = liste_d
VC = calcul_VC(D_app,beta_0,beta_d,d);
liste_VC = [liste_VC VC];
end
toc;
% Tracé de la validation croisée Leave-one-out en fonction de d :
figure('Name','Validation croisee','Position',[0.4*L,0.05*H,0.6*L,0.7*H]);
plot(liste_d,liste_VC,'sr-','LineWidth',2);
set(gca,'FontSize',20);
xlabel('$d$','Interpreter','Latex','FontSize',30);
ylabel('$VC$','Interpreter','Latex','FontSize',30);
% Estimation du degré d et de l'écart-type sigma :
[d_estime,sigma_estime] = estimation_d_sigma_bis(liste_d,liste_VC);
fprintf('Estimation du degre : d = %d\n',d_estime);
fprintf('Estimation de l''ecart-type du bruit sur les donnees : %.3f\n',sigma_estime);
```
```
Estimation du degre : d = 5
Estimation de l'ecart-type du bruit sur les donnees : 0.563
```
<img src="exercice_4.svg">
# Exercice 5 (Optionnel)
```matlab
clear;
close all;
% constantes
beta_0 = 115;
beta_d = 123;
beta = [133,96,139,118];
n_app = 100;
pas_app = 1/(n_app-1);
x_j = 0:pas_app:1;
sigma = 0.5;
d = 5;
n = 10000;
beta_moyen = zeros(1, d-1)';
sigma_moyen = 0;
for i=1:n
% génération de nouveaux points d'apprentissage
y_j = bezier_bruitee(beta_0,beta,beta_d,x_j,sigma);
D_app = [x_j ; y_j];
beta_estime = moindres_carres(D_app,beta_0,beta_d,d);
beta_moyen = beta_moyen + beta_estime/n;
end
[beta' , beta_moyen]
```
```matlab
>> exercice_5
ans =
133.0000 133.0007
96.0000 96.0013
139.0000 138.9989
118.0000 118.0024
```

53
TP10/ITFCT.m Executable file
View file

@ -0,0 +1,53 @@
function [y, valeurs_t] = ITFCT(Y, f_ech, n_decalage, fenetre)
% ITFCT (inverse de la transformée de Fourier à court terme)
% Par Overlap - Add
%
% Inputs :
% Y : TFCT d'un signal réel
% f_ech : fréquence d'échantillonnage
% n_decalage : taille entre deux fenêtres
%
% Outputs :
% y : ITFCT(Y)
% valeurs_t : points temporels
% On retrouve la taille de la fenêtre d'origine
% (on a enlevé presque la moitié des valeurs) :
n_fenetre = (size(Y, 1) - 1) * 2;
% On redonne la bonne taille à Y (pas besoin de remettre les bons coefficients,
% la fonction ifft de Matlab gère pour nous) :
Y(size(Y, 1) + 1:n_fenetre, :) = 0;
% Récupération de la fenêtre utilisée :
if nargin == 3 || strcmp(fenetre, 'hann')
% Par défaut, hanning
w = hann(n_fenetre);
elseif strcmp(fenetre, 'rect')
w = ones(n_fenetre, 1);
end
% Création d'un signal vierge et d'une variable permettant de calculer la somme des fenêtres :
n = (size(Y, 2) + 1) * n_decalage;
y = zeros(n, 1);
w_sum = zeros(n, 1);
for valeurs_t = 1:size(Y, 2)
% On retrouve le signal fenêtré (l'option 'symmetric' indique à
% Matlab d'utiliser la symétrie hermitienne de la TFCT d'un signal réel) :
y_win = ifft(Y(:, valeurs_t), 'symmetric');
% On ajoute ce tronçon de signal fenêtré au signal,
% et la fenêtre à la somme des fenêtres :
start = 1 + (valeurs_t - 1) * n_decalage;
y(start:start + n_fenetre - 1) = y(start:start + n_fenetre - 1) + y_win;
w_sum(start:start + n_fenetre - 1) = w_sum(start:start + n_fenetre - 1) + w;
end
% On dé-fenêtre (en évitant de diviser par 0) :
y = y ./ (w_sum + eps);
% Calcul des valeurs temporelles correspondant à chaque point du signal :
valeurs_t = (0:length(y) - 1) / f_ech;
end

16
TP10/TFCT.m Normal file
View file

@ -0,0 +1,16 @@
function [Y, valeurs_tau, valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre)
Y = buffer(y, n_fenetre, n_fenetre - n_decalage);
if fenetre == "hann"
f = hann(n_fenetre);
Y = Y .* f;
end
Y = fft(Y);
Y = Y(1:size(Y, 1) / 2, :);
valeurs_tau = 0:(1 / f_ech):(size(y, 1) / f_ech);
valeurs_f = 0:1 / size(Y, 1):f_ech;
end

21
TP10/TFCTST.m Normal file
View file

@ -0,0 +1,21 @@
function [Y, valeurs_tau, valeurs_f] = TFCTST(y, f_ech, n_fenetre, n_decalage, fenetre)
Y = buffer(y, n_fenetre, n_fenetre - n_decalage);
if fenetre == "hann"
f = hann(n_fenetre);
Y = Y .* f;
end
Y = fft(Y);
Y = Y(1:size(Y, 1) / 2, :);
valeurs_tau = 0:(1 / f_ech):(size(y, 1) / f_ech);
valeurs_f = 0:1 / size(Y, 1):f_ech;
% tronquage à 16kHz
seuil = 20000;
Y(1:floor(seuil / f_ech * size(Y, 1)), :) = [];
Y = Y * 1000;
end

22
TP10/TFCTT.m Normal file
View file

@ -0,0 +1,22 @@
function [Y, Y_plot, valeurs_tau, valeurs_f] = TFCTT(y, f_ech, n_fenetre, n_decalage, fenetre)
Y = buffer(y, n_fenetre, n_fenetre - n_decalage);
if fenetre == "hann"
f = hann(n_fenetre);
Y = Y .* f;
end
Y = fft(Y);
Y = Y(1:size(Y, 1) / 2, :);
valeurs_tau = 0:(1 / f_ech):(size(y, 1) / f_ech);
valeurs_f = 0:1 / size(Y, 1):f_ech;
% tronquage à 16kHz
seuil = 16000;
Y_plot = Y;
Y(floor(seuil / f_ech * size(Y, 1):end), :) = 0;
Y_plot(floor(seuil / f_ech * size(Y, 1):end), :) = mean(Y_plot(floor(seuil / f_ech * size(Y, 1):end), :), "all");
end

21
TP10/auto.m Normal file
View file

@ -0,0 +1,21 @@
files = dir('Audio/*.wav');
for i=1:length(files)
clearvars -except files i
filename = "Audio/" + files(i).name(1:end-4);
lecture;
exercice_1;
restitution_1;
exercice_1_tronc;
restitution_1_tronc;
exercice_2;
restitution_2;
exercice_4;
end

12
TP10/debruitage.asv Normal file
View file

@ -0,0 +1,12 @@
function Y_debruite = debruitage(Y_sb, Y_b)
mu = mean(Y_sb, 2);
sigma = std(Y_sb, 1, 2);
alpha = 0.5;
seuil = mu + alpha * sigma;
masque = Y_b > seuil;
masque = imgaussfilt()
end

18
TP10/debruitage.m Normal file
View file

@ -0,0 +1,18 @@
function Y_debruite = debruitage(Y_sb, Y_b)
mu = mean(Y_b, 2);
sigma = std(Y_b, 1, 2);
alpha = 2;
masque = abs(Y_sb - mu) > abs(alpha * sigma);
masque = double(masque);
masque = imgaussfilt(masque, 5);
masque(masque == 0) = 0.01;
% imagesc(masque);
% axis xy;
% colorbar;
Y_debruite = Y_sb .* masque;
end

BIN
TP10/enregistrement.mat Normal file
View file

Binary file not shown.

23
TP10/exercice_1.m Executable file
View file

@ -0,0 +1,23 @@
% clear;
close all;
% load enregistrement;
% Calcul de la transformée de Fourier à court terme :
n_fenetre = 1024; % Largeur de la fenêtre (en nombre d'échantillons)
n_decalage = 512; % Décalage entre positions successives de la fenêtre (en nombre d'échantillons)
fenetre = 'hann'; % Type de la fenêtre : 'rect' ou 'hann'
[Y, valeurs_tau, valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre);
S = 20 * log10(abs(Y) + eps);
% Affichage du module de la transformée de Fourier à court terme :
figure('units','normalized','outerposition',[0 0 1 1])
imagesc(valeurs_tau, valeurs_f, S);
axis xy;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
drawnow;
export_fig(gcf, "saves/" + filename + "_TFCT.png", '-png', '-painters', '-m2');
% save exercice_1;

BIN
TP10/exercice_1.mat Normal file
View file

Binary file not shown.

24
TP10/exercice_1_tronc.m Executable file
View file

@ -0,0 +1,24 @@
% clear;
close all;
% load enregistrement;
% Calcul de la transformée de Fourier à court terme :
n_fenetre = 1024; % Largeur de la fenêtre (en nombre d'échantillons)
n_decalage = 512; % Décalage entre positions successives de la fenêtre (en nombre d'échantillons)
fenetre = 'hann'; % Type de la fenêtre : 'rect' ou 'hann'
[Y, Y_plot, valeurs_tau, valeurs_f] = TFCTT(y, f_ech, n_fenetre, n_decalage, fenetre);
S = 20 * log10(abs(Y) + eps);
S_plot = 20 * log10(abs(Y_plot) + eps);
% Affichage du module de la transformée de Fourier à court terme :
figure('units','normalized','outerposition',[0 0 1 1])
imagesc(valeurs_tau, valeurs_f, S_plot);
axis xy;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
drawnow;
export_fig(gcf, "saves/" + filename + "_TFCTT.png", '-png', '-painters', '-m2');
% save exercice_1;

36
TP10/exercice_2.m Executable file
View file

@ -0,0 +1,36 @@
% clear;
close all;
% load exercice_1;
% Paramètre à ajuster :
m = 100;
% Calcul de la TFCT :
[Y, valeurs_tau, valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre);
% Sélection des m coefficients de Fourier de plus grand module :
[valeurs_max, indices_max, taux_compression] = mp3(Y, m, length(y));
fprintf('Taux de compression : %.3f\n', taux_compression);
% Reconstitution de la TFCT à partir de indices_max et valeurs_max :
nb_colonnes = size(Y, 2);
Y_reconstitue = zeros(size(Y));
for i = 1:nb_colonnes
indices_max_i = indices_max(:, i);
Y_reconstitue(indices_max_i, i) = valeurs_max(:, i);
end
% Affichage de la TFCT reconstituée :
figure('units','normalized','outerposition',[0 0 1 1])
imagesc(valeurs_tau, valeurs_f, 20 * log10(abs(Y_reconstitue) + eps));
axis xy;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
title('Sonagramme de la TFCT reconstitue');
drawnow;
export_fig(gcf, "saves/" + filename + "_mp3.png", '-png', '-painters', '-m2');
% save exercice_2;

BIN
TP10/exercice_2.mat Normal file
View file

Binary file not shown.

36
TP10/exercice_3.m Executable file
View file

@ -0,0 +1,36 @@
% clear;
close all;
% load enregistrement;
% Calcul de la transformée de Fourier à court terme :
n_fenetre = 2^10; % Largeur de la fenêtre (en nombre d'échantillons)
n_decalage = n_fenetre; % Décalage entre positions successives de la fenêtre (en nombre d'échantillons)
fenetre = 'rect'; % Type de la fenêtre : 'rect' ou 'hann'
[Y, valeurs_tau, valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre);
S = 20 * log10(abs(Y) + eps);
% Affichage du module de la transformée de Fourier à court terme :
figure('Name', 'Transformée de Fourier');
imagesc(valeurs_tau, valeurs_f, S);
axis xy;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
drawnow;
[Y, valeurs_tau, valeurs_f] = TFCTST(y, f_ech, n_fenetre, n_decalage, fenetre);
S = 20 * log10(abs(Y) + eps);
% Affichage du module de la transformée de Fourier à court terme :
figure('Name', 'Transformée de Fourier steg');
imagesc(valeurs_tau, valeurs_f, S);
axis xy;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
drawnow;
[signal_restitue, ~] = ITFCT(Y, f_ech, n_decalage, fenetre);
audiowrite("test.wav", signal_restitue, f_ech);
% save exercice_1;

78
TP10/exercice_4.m Executable file
View file

@ -0,0 +1,78 @@
% clear;
close all;
taille_ecran = get(0, 'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
% Paramètres :
n_fenetre = 4096; % Largeur de la fenêtre (en nombre d'échantillons)
n_decalage = 2048; % Décalage entre deux fenêtres (en nombre d'échantillons)
fenetre = 'hann'; % Type de la fenêtre
f_min_bruit = 4000; % Fréquence min du bruit généré
f_max_bruit = 12000; % Fréquence max du bruit généré
SNR = 10; % Ratio signal/bruit (élevé => peu bruité)
% Chargement de l'enregistrement
% load enregistrement;
[Y_s, valeurs_tau, valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre);
S_s = 20 * log10(abs(Y_s) + eps);
% Génération du bruit :
y_b = (2 * rand(length(y), 1) - 1);
[Y_b, valeurs_tau, valeurs_f] = TFCT(y_b, f_ech, n_fenetre, n_decalage, fenetre);
f_min_bruit_ligne = round(f_min_bruit / (f_ech / 2) * size(Y_b, 1));
f_max_bruit_ligne = round(f_max_bruit / (f_ech / 2) * size(Y_b, 1));
Y_b([1:f_min_bruit_ligne - 1 f_max_bruit_ligne + 1:end], :) = 0;
Y_b = Y_b / SNR;
S_b = 20 * log10(abs(Y_b) + eps);
% Ajout du bruit :
Y_sb = Y_s + Y_b;
S_sb = 20 * log10(abs(Y_sb) + eps);
[y_sb, ~] = ITFCT(Y_sb, f_ech, n_decalage, fenetre);
% À faire :
Y_debruite = debruitage(Y_sb, Y_b);
[y_debruite, ~] = ITFCT(Y_debruite, f_ech, n_decalage, fenetre);
% Affichage du signal et du bruit :
% figure('Name', 'Signal et bruit', 'Position', [0.4 * L, 0, 0.6 * L, 0.6 * H]);
% subplot(2, 2, 1);
% imagesc(valeurs_tau, valeurs_f, S_s);
% axis xy;
% xlabel('Temps ($s$)', 'Interpreter', 'Latex');
% ylabel('Frequence ($Hz$)', 'Interpreter', 'Latex');
% title('Signal');
%
% subplot(2, 2, 2);
% imagesc(valeurs_tau, valeurs_f, S_b);
% axis xy;
% xlabel('Temps ($s$)', 'Interpreter', 'Latex');
% ylabel('Frequence ($Hz$)', 'Interpreter', 'Latex');
% title('Bruit');
figure('units','normalized','outerposition',[0 0 1 1])
imagesc(valeurs_tau, valeurs_f, S_sb);
axis xy;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
drawnow;
export_fig(gcf, "saves/" + filename + "_bruit.png", '-png', '-painters', '-m2');
audiowrite("saves/" + filename + "_bruit.wav", y_sb, f_ech);
S_dn = 20 * log10(abs(Y_debruite) + eps);
figure('units','normalized','outerposition',[0 0 1 1])
imagesc(valeurs_tau, valeurs_f, S_dn);
axis xy;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
drawnow;
export_fig(gcf, "saves/" + filename + "_denoised.png", '-png', '-painters', '-m2');
audiowrite("saves/" + filename + "_denoised.wav", y_debruite, f_ech);

74
TP10/exercice_4.m.old Executable file
View file

@ -0,0 +1,74 @@
% clear;
close all;
taille_ecran = get(0, 'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
% Paramètres :
n_fenetre = 4096; % Largeur de la fenêtre (en nombre d'échantillons)
n_decalage = 2048; % Décalage entre deux fenêtres (en nombre d'échantillons)
fenetre = 'hann'; % Type de la fenêtre
f_min_bruit = 4000; % Fréquence min du bruit généré
f_max_bruit = 12000; % Fréquence max du bruit généré
SNR = 10; % Ratio signal/bruit (élevé => peu bruité)
% Chargement de l'enregistrement
% load enregistrement;
[Y_s, valeurs_tau, valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre);
S_s = 20 * log10(abs(Y_s) + eps);
% Génération du bruit :
y_b = (2 * rand(length(y), 1) - 1);
[Y_b, valeurs_tau, valeurs_f] = TFCT(y_b, f_ech, n_fenetre, n_decalage, fenetre);
f_min_bruit_ligne = round(f_min_bruit / (f_ech / 2) * size(Y_b, 1));
f_max_bruit_ligne = round(f_max_bruit / (f_ech / 2) * size(Y_b, 1));
Y_b([1:f_min_bruit_ligne - 1 f_max_bruit_ligne + 1:end], :) = 0;
Y_b = Y_b / SNR;
S_b = 20 * log10(abs(Y_b) + eps);
% Ajout du bruit :
Y_sb = Y_s + Y_b;
S_sb = 20 * log10(abs(Y_sb) + eps);
[y_sb, ~] = ITFCT(Y_sb, f_ech, n_decalage, fenetre);
% À faire :
Y_debruite = debruitage(Y_sb, Y_b);
[y_debruite, ~] = ITFCT(Y_debruite, f_ech, n_decalage, fenetre);
% Affichage du signal et du bruit :
figure('Name', 'Signal et bruit', 'Position', [0.4 * L, 0, 0.6 * L, 0.6 * H]);
subplot(2, 2, 1);
imagesc(valeurs_tau, valeurs_f, S_s);
axis xy;
xlabel('Temps ($s$)', 'Interpreter', 'Latex');
ylabel('Frequence ($Hz$)', 'Interpreter', 'Latex');
title('Signal');
subplot(2, 2, 2);
imagesc(valeurs_tau, valeurs_f, S_b);
axis xy;
xlabel('Temps ($s$)', 'Interpreter', 'Latex');
ylabel('Frequence ($Hz$)', 'Interpreter', 'Latex');
title('Bruit');
subplot(2, 2, 3);
imagesc(valeurs_tau, valeurs_f, S_sb);
axis xy;
xlabel('Temps ($s$)', 'Interpreter', 'Latex');
ylabel('Frequence ($Hz$)', 'Interpreter', 'Latex');
title('Signal + Bruit');
colorbar;
subplot(2, 2, 4);
imagesc(valeurs_tau, valeurs_f, 20 * log10(abs(Y_debruite) + eps));
axis xy;
xlabel('Temps ($s$)', 'Interpreter', 'Latex');
ylabel('Frequence ($Hz$)', 'Interpreter', 'Latex');
title('Signal debruite');
colorbar;
drawnow;

13
TP10/lecture.m Executable file
View file

@ -0,0 +1,13 @@
% clear;
% filename = 'Audio/message_cache';
% filename = 'Audio/mpl';
[y, f_ech] = audioread(filename + ".wav");
if size(y, 2) > 1
y = mean(y, 2);
end
% sound(y,f_ech);
% save enregistrement;

7
TP10/mp3.m Normal file
View file

@ -0,0 +1,7 @@
function [valeurs_max, indices_max, taux_compression] = mp3(Y, m, l)
[valeurs_max, indices_max] = maxk(Y, m);
taux_compression = length(valeurs_max(:)) * 2 / l;
end

30
TP10/restitution_1.m Executable file
View file

@ -0,0 +1,30 @@
% load exercice_1;
duree = length(y) / f_ech;
% disp('Reconstruction normale : tapez entree');
% pause;
% Restitution du signal à partir de la transformée de Fourier à court terme :
[signal_restitue, ~] = ITFCT(Y, f_ech, n_decalage, fenetre);
% sound(signal_restitue,f_ech);
audiowrite("saves/" + filename + "_restitution1.wav", signal_restitue, f_ech);
% pause(duree)
% disp('Apres suppression de la partie imaginaire du spectre : tapez entree');
% pause;
% Restitution du signal en n'utilisant que la partie réelle de la TFCT :
[signal_restitue, ~] = ITFCT(real(Y), f_ech, n_decalage, fenetre);
audiowrite("saves/" + filename + "_restitution1_reel.wav", signal_restitue, f_ech);
% sound(signal_restitue,f_ech);
% pause(duree)
% disp('Apres suppression de la phase du spectre : tapez entree');
% pause;
% Restitution du signal en n'utilisant que le module complexe de la TFCT :
[signal_restitue, ~] = ITFCT(abs(Y), f_ech, n_decalage, fenetre);
audiowrite("saves/" + filename + "_restitution1_module.wav", signal_restitue, f_ech);
% sound(signal_restitue,f_ech);

30
TP10/restitution_1_tronc.m Executable file
View file

@ -0,0 +1,30 @@
% load exercice_1;
duree = length(y) / f_ech;
% disp('Reconstruction normale : tapez entree');
% pause;
% Restitution du signal à partir de la transformée de Fourier à court terme :
[signal_restitue, ~] = ITFCT(Y, f_ech, n_decalage, fenetre);
% sound(signal_restitue,f_ech);
audiowrite("saves/" + filename + "_restitution1_tronc.wav", signal_restitue, f_ech);
% pause(duree)
% disp('Apres suppression de la partie imaginaire du spectre : tapez entree');
% pause;
% Restitution du signal en n'utilisant que la partie réelle de la TFCT :
[signal_restitue, ~] = ITFCT(real(Y), f_ech, n_decalage, fenetre);
audiowrite("saves/" + filename + "_restitution1_reel_tronc.wav", signal_restitue, f_ech);
% sound(signal_restitue,f_ech);
% pause(duree)
% disp('Apres suppression de la phase du spectre : tapez entree');
% pause;
% Restitution du signal en n'utilisant que le module complexe de la TFCT :
[signal_restitue, ~] = ITFCT(abs(Y), f_ech, n_decalage, fenetre);
audiowrite("saves/" + filename + "_restitution1_module_tronc.wav", signal_restitue, f_ech);
% sound(signal_restitue,f_ech);

6
TP10/restitution_2.m Executable file
View file

@ -0,0 +1,6 @@
% load exercice_2;
% Restitution du signal à partir de la TFCT reconstituée :
[signal_restitue, ~] = ITFCT(Y_reconstitue, f_ech, n_decalage, fenetre);
% sound(signal_restitue,f_ech);
audiowrite("saves/" + filename + "_restitution2.wav", signal_restitue, f_ech);

BIN
TP10/sujet_TP10.pdf Normal file
View file

Binary file not shown.

16
TP11/TFCT.m Normal file
View file

@ -0,0 +1,16 @@
function [Y, valeurs_tau, valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre)
Y = buffer(y, n_fenetre, n_fenetre - n_decalage, 'nodelay');
if fenetre == "hann"
f = hann(n_fenetre);
Y = Y .* f;
end
Y = fft(Y);
Y = Y(1:size(Y, 1) / 2 + 1, :);
valeurs_tau = n_decalage / f_ech * (0 : (size(Y, 2) - 1));
valeurs_f = (0:size(Y, 1)-1) * f_ech / n_fenetre;
end

7
TP11/ajout_bruit.m Executable file
View file

@ -0,0 +1,7 @@
function y = ajout_bruit(y,y_bruit,SNR)
E_y = sum(y.^2);
E_bruit = sum(y_bruit.^2);
rapport = sqrt(E_y/(E_bruit*SNR));
y = y+rapport*y_bruit;
y = y/max(y(:));

25
TP11/appariement.m Normal file
View file

@ -0,0 +1,25 @@
function paires = appariement(pics_t, pics_f)
delta_t = 90;
delta_f = 90;
n_voisins = 5;
n_pics = length(pics_t);
paires = [];
for i=1:n_pics
f = pics_f(i);
t = pics_t(i);
voisins = find(pics_t > t & pics_t <= t + delta_t & pics_f >= f - delta_f & pics_f <= f + delta_f, n_voisins);
for voisin=voisins'
paires = [paires ; f pics_f(voisin) t pics_t(voisin)];
end
end
end

BIN
TP11/bdd.mat Normal file
View file

Binary file not shown.

44
TP11/creation_bdd.m Executable file
View file

@ -0,0 +1,44 @@
clear;
close all;
chemin = '/mnt/n7fs/ens/tp_jmelou/Shazam/Morceaux/';
fichiers = dir([chemin '*.wav']);
bdd = containers.Map('KeyType','uint32','ValueType','any');
% Paramètres :
n_fenetre = 512; % Largeur de la fenêtre (en nombre de points)
n_decalage = 256; % Décalage entre deux fenêtres (en nombre de points)
fenetre = 'hann'; % Type de la fenêtre
for id = 1:length(fichiers)
% Lecture d'un fichier audio :
disp(fichiers(id).name);
[y,f_ech] = audioread([chemin fichiers(id).name]);
% Calcul du sonagramme :
[Y,valeurs_t,valeurs_f] = TFCT(y,f_ech,n_fenetre,n_decalage,fenetre);
S = 20*log10(abs(Y)+eps);
% Calcul des pics spectraux :
[pics_t,pics_f] = pics_spectraux(S);
% Calcul des paires de pics spectraux :
paires = appariement(pics_t,pics_f);
% Calcul des identifiants :
identifiants = indexation(paires);
% Stockage des identifiants :
for i = 1:length(identifiants)
identifiant = identifiants(i);
entree = [paires(i,3) id];
if bdd.isKey(identifiant)
bdd(identifiant) = [bdd(identifiant) ; entree];
else
bdd(identifiant) = entree;
end
end
end
save bdd.mat bdd;

41
TP11/exercice_1.m Executable file
View file

@ -0,0 +1,41 @@
clear;
close all;
taille_ecran = get(0, 'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
chemin = '/mnt/n7fs/ens/tp_jmelou/Shazam/Morceaux/';
fichiers = dir([chemin '*.wav']);
% Lecture d'un fichier audio :
numero_morceau = 02;
[y, f_ech] = audioread([chemin fichiers(numero_morceau).name]);
% Découpage d'un extrait de 15 secondes :
y = y(1:f_ech * 15);
% Paramètres :
n_fenetre = 512; % Largeur de la fenêtre (en nombre de points)
n_decalage = 256; % Décalage entre deux fenêtres (en nombre de points)
fenetre = 'hann'; % Type de la fenêtre
% Calcul du sonagramme :
[Y, valeurs_t, valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre);
S = 20 * log10(abs(Y) + eps);
% Calcul des pics spectraux :
[pics_t, pics_f] = pics_spectraux(S);
% Affichage du spectrogramme et des pics spectraux :
figure('units', 'normalized', 'outerposition', [0 0 1 1]);
imagesc(valeurs_t, valeurs_f, S);
caxis([-40 20]);
hold on;
plot(valeurs_t(pics_t), valeurs_f(pics_f), 'ro', 'MarkerSize', 7, 'MarkerFaceColor', 'r', 'LineWidth', 1);
axis xy;
title('Pics spectraux')
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
drawnow;
export_fig(gcf, "saves/exo1_" + num2str(numero_morceau) + ".png", '-png', '-painters', '-m2');

50
TP11/exercice_2.m Executable file
View file

@ -0,0 +1,50 @@
clear;
close all;
taille_ecran = get(0, 'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
chemin = '/mnt/n7fs/ens/tp_jmelou/Shazam/Morceaux/';
fichiers = dir([chemin '*.wav']);
% Lecture d'un fichier audio :
numero_morceau = 02;
[y, f_ech] = audioread([chemin fichiers(numero_morceau).name]);
% Découpage d'un extrait de 15 secondes :
y = y(1:f_ech * 15);
% Paramètres :
n_fenetre = 512; % Largeur de la fenêtre (en nombre de points)
n_decalage = 256; % Décalage entre deux fenêtres (en nombre de points)
fenetre = 'hann'; % Type de la fenêtre
% Calcul du sonagramme :
[Y, valeurs_t, valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre);
S = 20 * log10(abs(Y) + eps);
% Calcul des pics spectraux :
[pics_t, pics_f] = pics_spectraux(S);
% Calcul des paires de pics spectraux :
paires = appariement(pics_t, pics_f);
% Affichage du spectrogramme et des paires de pics spectraux :
figure('units', 'normalized', 'outerposition', [0 0 1 1]);
imagesc(valeurs_t, valeurs_f, S);
caxis([-40 20]);
hold on;
plot(valeurs_t(pics_t), valeurs_f(pics_f), 'ro', 'MarkerSize', 7, 'MarkerFaceColor', 'r', 'LineWidth', 1);
for i = 1:1:size(paires, 1)
hold on;
plot([valeurs_t(paires(i, 3)) valeurs_t(paires(i, 4))], ...
[valeurs_f(paires(i, 1)) valeurs_f(paires(i, 2))], 'r', 'LineWidth', 1);
end
axis xy;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
drawnow;
export_fig(gcf, "saves/exo2_" + num2str(numero_morceau) + ".png", '-png', '-painters', '-m2');

66
TP11/exercice_3.m Executable file
View file

@ -0,0 +1,66 @@
clear;
close all;
taille_ecran = get(0, 'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
chemin = '/mnt/n7fs/ens/tp_jmelou/Shazam/Morceaux/';
fichiers = dir([chemin '*.wav']);
% Chargement de la base de données :
load bdd;
% Lecture d'un fichier audio tiré aléatoirement :
numero_morceau = 69;
[y, f_ech] = audioread([chemin fichiers(numero_morceau).name]);
% Extrait de durée variable, tiré aléatoirement :
duree_extrait = 15; % Durée de l'extrait en secondes
debut_extrait = randi(length(y) - f_ech * duree_extrait + 1);
y = y(debut_extrait:debut_extrait + f_ech * duree_extrait - 1);
% Création d'un bruit (blanc ou de parole) :
y_bruit_blanc = randn(size(y));
y_bruit_parole = audioread('/mnt/n7fs/ens/tp_jmelou/Shazam/talking.wav');
debut_y_bruit_parole = randi(length(y_bruit_parole) - length(y) + 1);
y_bruit_parole = y_bruit_parole(debut_y_bruit_parole:debut_y_bruit_parole + length(y) - 1);
% Ajout du bruit (blanc et/ou de parole) :
SNR = 10; % Rapport signal sur bruit
% y = ajout_bruit(y,y_bruit_blanc,SNR);
% y = ajout_bruit(y,y_bruit_parole,SNR);
% sound(y,f_ech);
% pause(duree_extrait);
% Paramètres :
n_fenetre = 512; % Largeur de la fenêtre (en nombre de points)
n_decalage = 256; % Décalage entre deux fenêtres (en nombre de points)
fenetre = 'hann'; % Type de la fenêtre
% Calcul du sonagramme :
[Y, valeurs_t, valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre);
S = 20 * log10(abs(Y) + eps);
% Calcul des pics spectraux :
[pics_t, pics_f] = pics_spectraux(S);
% Calcul des paires de pics spectraux :
paires = appariement(pics_t, pics_f);
% Calcul des identifiants :
identifiants = indexation(paires);
% Récupération des empreintes présentes dans la base de données :
resultats = recherche_simplifiee(identifiants, bdd);
% Recherche du meilleur résultat :
[C, ia, ic] = unique(resultats, 'rows', 'stable');
h = accumarray(ic, 1);
[m, ind] = max(h);
numero_reconnu = C(ind, 1);
if numero_reconnu == numero_morceau
fprintf('Le morceau "%s" a ete correctement reconnu !\n', fichiers(numero_morceau).name(1:end - 4));
else
fprintf('Le morceau "%s" n''a pas ete reconnu !\n', fichiers(numero_morceau).name(1:end - 4));
end

66
TP11/exercice_4.m Executable file
View file

@ -0,0 +1,66 @@
clear;
close all;
taille_ecran = get(0, 'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
chemin = '/mnt/n7fs/ens/tp_jmelou/Shazam/Morceaux/';
fichiers = dir([chemin '*.wav']);
% Chargement de la base de données :
load bdd;
% Lecture d'un fichier audio tiré aléatoirement :
numero_morceau = 69;
[y, f_ech] = audioread([chemin fichiers(numero_morceau).name]);
% Extrait de durée variable, tiré aléatoirement :
duree_extrait = 15; % Durée de l'extrait en secondes
debut_extrait = randi(length(y) - f_ech * duree_extrait + 1);
y = y(debut_extrait:debut_extrait + f_ech * duree_extrait - 1);
% Création d'un bruit (blanc ou de parole) :
y_bruit_blanc = randn(size(y));
y_bruit_parole = audioread('/mnt/n7fs/ens/tp_jmelou/Shazam/talking.wav');
debut_y_bruit_parole = randi(length(y_bruit_parole) - length(y) + 1);
y_bruit_parole = y_bruit_parole(debut_y_bruit_parole:debut_y_bruit_parole + length(y) - 1);
% Ajout du bruit (blanc et/ou de parole) :
SNR = 10; % Rapport signal sur bruit
% y = ajout_bruit(y,y_bruit_blanc,SNR);
% y = ajout_bruit(y,y_bruit_parole,SNR);
% sound(y,f_ech);
% pause(duree_extrait);
% Paramètres :
n_fenetre = 512; % Largeur de la fenêtre (en nombre de points)
n_decalage = 256; % Décalage entre deux fenêtres (en nombre de points)
fenetre = 'hann'; % Type de la fenêtre
% Calcul du sonagramme :
[Y, valeurs_t, valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre);
S = 20 * log10(abs(Y) + eps);
% Calcul des pics spectraux :
[pics_t, pics_f] = pics_spectraux(S);
% Calcul des paires de pics spectraux :
paires = appariement(pics_t, pics_f);
% Calcul des identifiants :
identifiants = indexation(paires);
% Récupération des empreintes présentes dans la base de données :
resultats = recherche_avancee(identifiants, paires(:,3), bdd);
% Recherche du meilleur résultat :
[C, ia, ic] = unique(resultats, 'rows', 'stable');
h = accumarray(ic, 1);
[m, ind] = max(h);
numero_reconnu = C(ind, 1);
if numero_reconnu == numero_morceau
fprintf('Le morceau "%s" a ete correctement reconnu !\n', fichiers(numero_morceau).name(1:end - 4));
else
fprintf('Le morceau "%s" n''a pas ete reconnu !\n', fichiers(numero_morceau).name(1:end - 4));
end

6
TP11/indexation.m Executable file
View file

@ -0,0 +1,6 @@
function empreintes = indexation(paires)
f1 = rem(paires(:,1)-1,2^8);
f2 = rem(paires(:,2)-1,2^8);
t21 = rem(paires(:,4)-paires(:,3),2^16);
empreintes = uint32(f1*2^24+f2*2^16+t21);

10
TP11/pics_spectraux.m Normal file
View file

@ -0,0 +1,10 @@
function [pics_t, pics_f] = pics_spectraux(S)
tau = 30;
phi = 30;
epsilon = 1;
dilated = imdilate(S, true(phi, tau));
[pics_f, pics_t] = find(S == dilated & S > epsilon);
end

28
TP11/recherche_avancee.m Normal file
View file

@ -0,0 +1,28 @@
function resultats = recherche_simplifiee(identifiants, temps, bdd)
resultats = [];
for i = 1:length(identifiants)
if isKey(bdd, identifiants(i))
entry = bdd(identifiants(i));
if length(entry) == 0
continue;
end
resultats = [ resultats ; entry(:, 2), entry(:, 1) - temps(i) ];
end
end
[C, ia, ic] = unique(resultats(:,2), 'rows', 'stable');
h = accumarray(ic, 1);
[m, ind] = max(h);
start = C(ind, 1);
indexs = start * 0.9 <= resultats(:, 2) & resultats(:, 2) <= start + max(temps) * 1.1;
resultats = resultats(indexs, 1);
end

21
TP11/recherche_simplifiee.asv Normal file
View file

@ -0,0 +1,21 @@
function resultats = recherche_simplifiee(identifiants, bdd)
songs = [];
for i = 1:length(identifiants)
if isKey(map,keys(i))
entry = bdd(identifiants(i));
if length(entry) == 0
continue;
end
songs = [ songs ; entry(:, 1) ];
end
songs
end

19
TP11/recherche_simplifiee.m Normal file
View file

@ -0,0 +1,19 @@
function resultats = recherche_simplifiee(identifiants, bdd)
resultats = [];
for i = 1:length(identifiants)
if isKey(bdd, identifiants(i))
entry = bdd(identifiants(i));
if length(entry) == 0
continue;
end
resultats = [ resultats ; entry(:, 2) ];
end
end
end

115
TP11/statistiques.m Executable file
View file

@ -0,0 +1,115 @@
clear;
close all;
chemin = '/mnt/n7fs/ens/tp_jmelou/Shazam/Morceaux/';
fichiers = dir([chemin '*.wav']);
% Chargement de la base de données :
load bdd;
% Paramètres :
duree_extrait = 10; % Durée des extraits (en secondes)
n_fenetre = 512; % Largeur de la fenêtre (en nombre de points)
n_decalage = 256; % Décalage entre deux fenêtres (en nombre de points)
fenetre = 'hann'; % Type de la fenêtre
N_tests = 100; % Nombre de tests
nb_reconnus = 0;
f = waitbar(0,'Starting');
for i = 1:N_tests
% Lecture d'un fichier audio tiré aléatoirement :
numero_morceau = randi(length(fichiers));
[y,f_ech] = audioread([chemin fichiers(numero_morceau).name]);
% Extrait de durée variable, tiré aléatoirement :
debut_extrait = randi(length(y)-f_ech*duree_extrait);
y = y(debut_extrait:debut_extrait+f_ech*duree_extrait-1);
% Calcul du sonagramme :
[Y,valeurs_t,valeurs_f] = TFCT(y,f_ech,n_fenetre,n_decalage,fenetre);
S = 20*log10(abs(Y)+eps);
% Calcul des pics spectraux :
[pics_t,pics_f] = pics_spectraux(S);
% Calcul des paires :
paires = appariement(pics_t,pics_f);
if length(paires)<1
nb_reconnus = nb_reconnus+1;
continue;
end
% Calcul des identifiants :
identifiants = indexation(paires);
% Comparaison des identifiants :
resultats = recherche_simplifiee(identifiants,bdd);
if length(resultats)<1
continue;
end
[C,ia,ic] = unique(resultats,'rows','stable');
h = accumarray(ic,1);
[m,ind] = max(h);
numero_reconnu = C(ind,1);
if numero_reconnu==numero_morceau
nb_reconnus = nb_reconnus+1;
end
waitbar(i/N_tests,f,sprintf('Progress: %d %%',floor(i/N_tests*100)));
end
fprintf('Precision : %4.1f %% \n',nb_reconnus/N_tests*100);
close(f);
nb_reconnus = 0;
f = waitbar(0,'Starting');
for i = 1:N_tests
% Lecture d'un fichier audio tiré aléatoirement :
numero_morceau = randi(length(fichiers));
[y,f_ech] = audioread([chemin fichiers(numero_morceau).name]);
% Extrait de durée variable, tiré aléatoirement :
debut_extrait = randi(length(y)-f_ech*duree_extrait);
y = y(debut_extrait:debut_extrait+f_ech*duree_extrait-1);
% Calcul du sonagramme :
[Y,valeurs_t,valeurs_f] = TFCT(y,f_ech,n_fenetre,n_decalage,fenetre);
S = 20*log10(abs(Y)+eps);
% Calcul des pics spectraux :
[pics_t,pics_f] = pics_spectraux(S);
% Calcul des paires :
paires = appariement(pics_t,pics_f);
if length(paires)<1
nb_reconnus = nb_reconnus+1;
continue;
end
% Calcul des identifiants :
identifiants = indexation(paires);
% Comparaison des identifiants :
resultats = recherche_avancee(identifiants, paires(:,3), bdd);
if length(resultats)<1
continue;
end
[C,ia,ic] = unique(resultats,'rows','stable');
h = accumarray(ic,1);
[m,ind] = max(h);
numero_reconnu = C(ind,1);
if numero_reconnu==numero_morceau
nb_reconnus = nb_reconnus+1;
end
waitbar(i/N_tests,f,sprintf('Progress: %d %%',floor(i/N_tests*100)));
end
fprintf('Precision : %4.1f %% \n',nb_reconnus/N_tests*100);
close(f);

38
TP11/verif_TFCT.m Executable file
View file

@ -0,0 +1,38 @@
clear;
close all;
load verif_TFCT;
f_ech = 10;
y = (1:8);
n_fenetre = 4;
n_decalage = 3;
fenetre = 'hann';
[Y,valeurs_t,valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre);
if size(Y,1)~=(n_fenetre/2+1)
disp('Le nombre de lignes n''est pas bon : avez-vous supprime les frequences negatives ?');
end
if size(Y,2)~=ceil((length(y)-n_fenetre)/n_decalage)+1
disp('Le nombre de colonnes n''est pas bon : verifiez l''appel a la fonction buffer !');
end
if ~isequal(Y,cell2mat(test_1(1)))
Y
cell2mat(test_1(1))
disp('La matrice TFCT n''est pas correte : le fenetrage a-t-il ete effectue correctement ?')
end
if ~isequal(valeurs_f,cell2mat(test_1(2)))
valeurs_f
cell2mat(test_1(2))
disp('Les valeurs de f ne sont pas correctes : vont-elles bien de 0 Hz a f_ech/2 Hz ?')
end
if ~isequal(valeurs_t,cell2mat(test_1(3)))
valeurs_t
cell2mat(test_1(3))
disp('Les valeurs de tau ne sont pas correctes : quand le segment analyse debute-t-il dans la k-ieme colonne de la TFCT ?')
end

BIN
TP11/verif_TFCT.mat Executable file
View file

Binary file not shown.

10
TP12/HPSS.m Normal file
View file

@ -0,0 +1,10 @@
function [F_h, F_p] = HPSS(S)
n1 = 17;
n2 = 17;
F_h = medfilt2(S,[1 n1]);
F_p = medfilt2(S,[n2 1]);
end

55
TP12/ITFCT.m Executable file
View file

@ -0,0 +1,55 @@
function [y, valeurs_t] = ITFCT(Y, f_ech, n_decalage, fenetre)
% ITFCT (inverse de la transformée de Fourier à court terme)
% Par Overlap - Add
%
% Inputs :
% Y : TFCT d'un signal réel
% f_ech : fréquence d'échantillonage
% n_decalage : taille entre deux fenêtres
% fenetre : type de fenêtre
%
% Outputs :
% y : ITFCT(Y)
% valeurs_t : points temporels
% On retrouve la taille de la fenêtre d'origine
% (on a enlevé presque la moitié des valeurs) :
n_fenetre = (size(Y, 1) - 1) * 2;
% On redonne la bonne taille à Y (pas besoin de remettre les bons coefficients,
% la fonction ifft de Matlab gère pour nous) :
Y(size(Y, 1) + 1:n_fenetre, :) = 0;
% Récupération de la fenêtre utilisée :
switch fenetre
case 'rect'
w = ones(n_fenetre, 1);
otherwise
w = hann(n_fenetre);
end
% Création d'un signal vierge et d'une variable permettant de calculer la somme des fenêtres :
n = (size(Y, 2) + 1) * n_decalage;
y = zeros(n, 1);
w_sum = zeros(n, 1);
for valeurs_t = 1:size(Y,2)
% On retrouve le signal fenêtré (l'option 'symmetric' indique à
% Matlab d'utiliser la symétrie hermitienne de la TFCT d'un signal réel) :
y_win = ifft(Y(:, valeurs_t), 'symmetric');
% On ajoute ce tronçon de signal fenêtré au signal,
% et la fenêtre à la somme des fenêtres :
start = 1 + (valeurs_t-1)*n_decalage;
y(start : start + n_fenetre - 1) = y(start : start + n_fenetre - 1) + y_win;
w_sum(start : start + n_fenetre - 1) = w_sum(start : start + n_fenetre - 1) + w;
end
% On dé-fenêtre (en évitant de diviser par 0) :
y = y ./ (w_sum + eps);
% Calcul des valeurs temporelles correspondant à chaque point du signal :
valeurs_t = (0:length(y)-1) / f_ech;
end

16
TP12/TFCT.m Normal file
View file

@ -0,0 +1,16 @@
function [Y, valeurs_tau, valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre)
Y = buffer(y, n_fenetre, n_fenetre - n_decalage, 'nodelay');
if fenetre == "hann"
f = hann(n_fenetre);
Y = Y .* f;
end
Y = fft(Y);
Y = Y(1:size(Y, 1) / 2 + 1, :);
valeurs_tau = n_decalage / f_ech * (0 : (size(Y, 2) - 1));
valeurs_f = (0:size(Y, 1)-1) * f_ech / n_fenetre;
end

146
TP12/exercice_1.m Executable file
View file

@ -0,0 +1,146 @@
clear;
close all;
taille_ecran = get(0, 'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
% Lecture des fichiers séparés :
[y_h, f_ech] = audioread('Musiques/violon.wav');
[y_p, f_ech] = audioread('Musiques/batterie.wav');
% Création du mélange :
taille = min(length(y_h), length(y_p));
y_h = y_h(1:taille);
y_p = y_p(1:taille);
y = y_h + y_p;
% Passage dans le domaine fréquentiel :
n_fenetre = 1024; % Largeur de la fenêtre (en nombre de points)
n_decalage = 512; % Décalage entre deux fenêtres (en nombre de points)
fenetre = 'hann'; % Type de la fenêtre
[Y_h, valeurs_t, valeurs_f] = TFCT(y_h, f_ech, n_fenetre, n_decalage, fenetre);
S_h = 20 * log10(abs(Y_h) + eps);
[Y_p, valeurs_t, valeurs_f] = TFCT(y_p, f_ech, n_fenetre, n_decalage, fenetre);
S_p = 20 * log10(abs(Y_p) + eps);
[Y, valeurs_t, valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre);
S = 20 * log10(abs(Y) + eps);
% Séparation harmonique/percussive :
[F_h, F_p] = HPSS(abs(Y).^2);
% Création des masques :
% M_h = F_h >= F_p;
% M_p = F_p > F_h;
M_h = F_h ./ (F_h + F_p);
M_p = F_p ./ (F_h + F_p);
% Application des masques :
Y_h_hat = M_h .* Y;
Y_p_hat = M_p .* Y;
% Retour dans le domaine temporel :
[y_h_hat, ~] = ITFCT(Y_h_hat, f_ech, n_decalage, fenetre);
[y_p_hat, ~] = ITFCT(Y_p_hat, f_ech, n_decalage, fenetre);
% Normalisation :
y_h_hat = min(max(y_h_hat, -1), 1);
y_p_hat = min(max(y_p_hat, -1), 1);
% Sauvegarde :
audiowrite('/work/lfainsin-matlab/TP12/exo1_HPSS_harmonique.wav', y_h_hat, f_ech);
audiowrite('/work/lfainsin-matlab/TP12/exo1_HPSS_percussive.wav', y_p_hat, f_ech);
audiowrite('/work/lfainsin-matlab/TP12/exo1_combined.wav', y, f_ech);
% Figures :
figure('units', 'normalized', 'outerposition', [0 0 1 1]);
imagesc(valeurs_t, valeurs_f, S_h);
caxis([-40 20]);
axis xy;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
title('$\mathbf{S}_{h}$', 'Interpreter', 'Latex');
drawnow;
export_fig(gcf, "/work/lfainsin-matlab/TP12/exo1_sono_h.png", '-png', '-painters', '-m2');
figure('units', 'normalized', 'outerposition', [0 0 1 1]);
imagesc(valeurs_t, valeurs_f, S_p);
caxis([-40 20]);
axis xy;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
title('$\mathbf{S}_{p}$', 'Interpreter', 'Latex');
drawnow;
export_fig(gcf, "/work/lfainsin-matlab/TP12/exo1_sono_p.png", '-png', '-painters', '-m2');
% Sonagramme du mélange :
figure('units', 'normalized', 'outerposition', [0 0 1 1]);
imagesc(valeurs_t, valeurs_f, S);
caxis([-40 20]);
axis xy;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
title('$\mathbf{S}$', 'Interpreter', 'Latex');
drawnow;
export_fig(gcf, "/work/lfainsin-matlab/TP12/exo1_sono_mélange.png", '-png', '-painters', '-m2');
% Sonagramme filtrés :
figure('units', 'normalized', 'outerposition', [0 0 1 1]);
imagesc(valeurs_t, valeurs_f, log10(F_h));
axis xy;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
title('$\mathbf{F}_{h}$', 'Interpreter', 'Latex');
drawnow;
export_fig(gcf, "/work/lfainsin-matlab/TP12/exo1_sono_filter_h.png", '-png', '-painters', '-m2');
figure('units', 'normalized', 'outerposition', [0 0 1 1]);
imagesc(valeurs_t, valeurs_f, log10(F_p));
axis xy;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
title('$\mathbf{F}_{p}$', 'Interpreter', 'Latex');
drawnow;
export_fig(gcf, "/work/lfainsin-matlab/TP12/exo1_sono_filter_p.png", '-png', '-painters', '-m2');
% Affichage des masques :
figure('units', 'normalized', 'outerposition', [0 0 1 1]);
imagesc(valeurs_t, valeurs_f, M_h);
axis xy; axis tight; colormap gray;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
title('$\mathbf{M}_{h}$', 'Interpreter', 'Latex');
drawnow;
export_fig(gcf, "/work/lfainsin-matlab/TP12/exo1_mask_h.png", '-png', '-painters', '-m2');
figure('units', 'normalized', 'outerposition', [0 0 1 1]);
imagesc(valeurs_t, valeurs_f, M_p);
axis xy; axis tight; colormap gray;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
title('$\mathbf{M}_{p}$', 'Interpreter', 'Latex');
drawnow;
export_fig(gcf, "/work/lfainsin-matlab/TP12/exo1_mask_p.png", '-png', '-painters', '-m2');
% Affichage des sonagrammes masqués :
figure('units', 'normalized', 'outerposition', [0 0 1 1]);
imagesc(valeurs_t, valeurs_f, 20 * log10(abs(Y_h_hat + eps)));
axis xy; axis tight;
caxis([-40 20]);
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
title('$\hat{\mathbf{S}}_{h}$', 'Interpreter', 'Latex');
drawnow;
export_fig(gcf, "/work/lfainsin-matlab/TP12/exo1_sono_masked_h.png", '-png', '-painters', '-m2');
figure('units', 'normalized', 'outerposition', [0 0 1 1]);
imagesc(valeurs_t, valeurs_f, 20 * log10(abs(Y_p_hat + eps)));
axis xy; axis tight;
caxis([-40 20]);
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
title('$\hat{\mathbf{S}}_{p}$', 'Interpreter', 'Latex');
drawnow;
export_fig(gcf, "/work/lfainsin-matlab/TP12/exo1_sono_masked_p.png", '-png', '-painters', '-m2');

55
TP12/exercice_2.asv Normal file
View file

@ -0,0 +1,55 @@
clear;
close all;
taille_ecran = get(0,'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
% Lecture d'un fichier audio :
[y, f_ech] = audioread('Musiques/Au clair de la lune.wav');
% Passage dans le domaine fréquentiel :
n_fenetre = 1024; % Largeur de la fenêtre (en nombre de points)
n_decalage = 512; % Décalage entre deux fenêtres (en nombre de points)
fenetre = 'hann'; % Type de la fenêtre
[Y,valeurs_t,valeurs_f] = TFCT(y,f_ech,n_fenetre,n_decalage,fenetre);
S = 20*log10(abs(Y)+eps);
% NMF :
R = 4;
D_0 = rand(size(S,1),R);
A_0 = rand(R,size(S,2));
[D,A] = nmf(abs(Y),D_0,A_0,300);
% Sauvegarde de chaque composante :
for r = 1:R
Y_r = (D(:,r)*A(r,:)) ./ (D*A) .* Y;
[y_r,~] = ITFCT(Y_r,f_ech,n_decalage,fenetre);
audiowrite(['/work/lfainsin-matlab/TP12//composante_' int2str(r) '.wav'],y_r,f_ech);
end
% Figures :
figure('Name','Dictionnaire et activations en sortie du NMF','Position',[0.4*L,0,0.6*L,0.6*H]);
subplot(1,2,1);
imagesc(1:R,valeurs_f,20*log10(abs(D)));
set(gca,'xtick',1:R)
caxis([-40 10]);
axis xy;
xlabel('Composantes','Interpreter','Latex','FontSize',30);
ylabel('Frequence ($Hz$)','Interpreter','Latex','FontSize',30);
title('$\mathbf{D}$','Interpreter','Latex','FontSize',30);
subplot(1,2,2);
imagesc(valeurs_t,1:R,A);
set(gca,'ytick',1:R)
axis xy;
xlabel('Temps ($s$)','Interpreter','Latex','FontSize',30);
ylabel('Composantes','Interpreter','Latex','FontSize',30);
title('$\mathbf{A}$','Interpreter','Late20*log10(abs(D * A)+epzdqzd s)x','FontSize',30);
figure;
imagesc(valeurs_t,valeurs_f,prod);
caxis([-40 20]);
zdxlabel('Temps ($s$)','Interpreter','Latex','FontSize',30);
ylabel('Frequence ($Hz$)','Interpreter','Latex','FontSize',30);
title('$\mathbf{S}$','Interpreter','Latex','FontSize',30);

88
TP12/exercice_2.m Executable file
View file

@ -0,0 +1,88 @@
clear;
close all;
taille_ecran = get(0, 'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
% Lecture d'un fichier audio :
[y, f_ech] = audioread('Musiques/Au clair de la lune.wav');
% Passage dans le domaine fréquentiel :
n_fenetre = 1024; % Largeur de la fenêtre (en nombre de points)
n_decalage = 512; % Décalage entre deux fenêtres (en nombre de points)
fenetre = 'hann'; % Type de la fenêtre
[Y, valeurs_t, valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre);
S = 20 * log10(abs(Y) + eps);
% figure('units', 'normalized', 'outerposition', [0 0 1 1]);
% imagesc(valeurs_t, valeurs_f, S);
% axis xy;
% xlabel('Temps (s)');
% ylabel('Frequence (Hz)');
% title('$\mathbf{S}$', 'Interpreter', 'Latex');
% drawnow;
% export_fig(gcf, "/work/lfainsin-matlab/TP12/exo2_sonogramme.png", '-png', '-painters', '-m2');
% NMF :
R = 25;
D_0 = rand(size(S, 1), R);
A_0 = rand(R, size(S, 2));
[D, A] = nmf(abs(Y), D_0, A_0, 30, 1, "exo2", valeurs_t, valeurs_f, R);
% Sauvegarde de chaque composante :
figure('units', 'normalized', 'outerposition', [0 0 1 1]);
for r = 1:R
Y_r = (D(:, r) * A(r, :)) ./ (D * A) .* Y;
[y_r, ~] = ITFCT(Y_r, f_ech, n_decalage, fenetre);
y_r = min(max(y_r, -1), 1);
audiowrite(['/work/lfainsin-matlab/TP12/exo2_composante_' int2str(r) '_' int2str(R) '.wav'], y_r, f_ech);
S_r = 20 * log10(abs(Y_r) + eps);
imagesc(valeurs_t, valeurs_f, S_r);
axis xy;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
title("$\mathbf{S_{r" + int2str(r) + "}}$", 'Interpreter', 'Latex');
drawnow;
export_fig(gcf, "/work/lfainsin-matlab/TP12/exo2_mask_" + int2str(r) + "_" + int2str(R) + ".png", '-png', '-painters', '-m2');
end
% % Figures :
% figure('units', 'normalized', 'outerposition', [0 0 1 1]);
% imagesc(1:R, valeurs_f, 20 * log10(abs(D)));
% set(gca, 'xtick', 1:R)
% caxis([-40 10]);
% axis xy;
% xlabel('Composantes');
% ylabel('Frequence (Hz)');
% title('$\mathbf{D}$', 'Interpreter', 'Latex');
% drawnow;
% export_fig(gcf, "/work/lfainsin-matlab/TP12/exo2_dico_" + int2str(R) + ".png", '-png', '-painters', '-m2');
%
% figure('units', 'normalized', 'outerposition', [0 0 1 1]);
% imagesc(valeurs_t, 1:R, A);
% set(gca, 'ytick', 1:R)
% axis xy;
% xlabel('Temps (s)');
% ylabel('Composantes');
% title('$\mathbf{A}$', 'Interpreter', 'Latex');
% drawnow;
% export_fig(gcf, "/work/lfainsin-matlab/TP12/exo2_activ_" + int2str(R) + ".png", '-png', '-painters', '-m2');
%
% figure('units', 'normalized', 'outerposition', [0 0 1 1]);
% prod = 20 * log10(abs(Y_final) + eps);
% imagesc(valeurs_t, valeurs_f, prod);
% axis xy;
% xlabel('Temps (s)');
% ylabel('Frequence (Hz)');
% title('$\mathbf{S}$', 'Interpreter', 'Latex');
% drawnow;
% export_fig(gcf, "/work/lfainsin-matlab/TP12/exo2_sonoprod_" + int2str(R) + ".png", '-png', '-painters', '-m2');
Y_final = D * A;
[y_final, ~] = ITFCT(Y_final, f_ech, n_decalage, fenetre);
y_final = min(max(y_final, -1), 1);
audiowrite(['/work/lfainsin-matlab/TP12/exo2_final_' int2str(R) '.wav'], y_final, f_ech);

57
TP12/exercice_3.m Executable file
View file

@ -0,0 +1,57 @@
clear;
close all;
taille_ecran = get(0, 'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
% Lecture d'un fichier audio :
[y, f_ech] = audioread('Musiques/Au clair de la lune.wav');
% Passage au domaine fréquentiel :
n_fenetre = 1024; % Largeur de la fenêtre (en nombre de points)
n_decalage = 512; % Décalage entre deux fenêtres (en nombre de points)
fenetre = 'hann'; % Type de la fenêtre
[Y, valeurs_t, valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre);
S = 20 * log10(abs(Y) + eps);
% NMF :
% fichiers_notes_piano = dir('Musiques/Notes/Piano/');
% fichiers_notes_piano = {fichiers_notes_piano(3:end).name};
% fichiers_notes_piano = {'C5.wav','D5.wav','E5.wav'};
fichiers_notes_piano = {'C5.wav', 'Db5.wav', 'D5.wav', 'Eb5.wav', 'E5.wav', 'F5.wav', 'Gb5.wav', 'G5.wav', 'Ab5.wav', 'A5.wav', 'Bb5.wav', 'B5.wav'};
chemins_notes_piano = strcat('Musiques/Notes/Piano/', fichiers_notes_piano);
D_0 = initialisation_notes(chemins_notes_piano, n_fenetre, n_decalage, fenetre);
A_0 = rand(size(D_0, 2), size(S, 2));
[D, A] = nmf(abs(Y), D_0, A_0, 30, 1, "exo3", valeurs_t, valeurs_f, length(chemins_notes_piano));
% Figures :
% figure('Name', 'Dictionnaire et activations en sortie du NMF', 'Position', [0.4 * L, 0, 0.6 * L, 0.6 * H]);
% subplot(1, 2, 1);
% imagesc(1:size(D, 2), valeurs_f, 20 * log10(abs(D)));
% set(gca, 'xtick', 1:size(D, 2));
% caxis([-40 10]);
% axis xy;
% xlabel('Composantes');
% ylabel('Frequence (Hz)');
% title('$\mathbf{D}$', 'Interpreter', 'Latex');
% subplot(1, 2, 2);
% imagesc(valeurs_t, 1:size(D, 2), A);
% set(gca, 'ytick', 1:size(D, 2));
% axis xy;
% xlabel('Temps (s)');
% ylabel('Composantes');
% title('$\mathbf{A}$', 'Interpreter', 'Latex');
% figure;
% prod = 20 * log10(abs(D * A) + eps);
% imagesc(valeurs_t, valeurs_f, prod);
% axis xy;
% xlabel('Temps (s)');
% ylabel('Frequence (Hz)');
% title('$\mathbf{S}$', 'Interpreter', 'Latex');
Y_final = D * A;
[y_final, ~] = ITFCT(Y_final, f_ech, n_decalage, fenetre);
audiowrite(['/work/lfainsin-matlab/TP12/exo3_final.wav'], y_final, f_ech);

0
TP12/exercice_3bis.asv Normal file
View file

45
TP12/exercice_3bis.m Executable file
View file

@ -0,0 +1,45 @@
clear;
close all;
taille_ecran = get(0, 'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
% Lecture d'un fichier audio :
[y, f_ech] = audioread('Musiques/Gounod.wav');
% Passage au domaine fréquentiel :
n_fenetre = 1024; % Largeur de la fenêtre (en nombre de points)
n_decalage = 512; % Décalage entre deux fenêtres (en nombre de points)
fenetre = 'hann'; % Type de la fenêtre
[Y, valeurs_t, valeurs_f] = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre);
S = 20 * log10(abs(Y) + eps);
% NMF :
fichiers_notes_piano = dir('Musiques/Notes/Piano/');
fichiers_notes_piano = {fichiers_notes_piano(3:end).name};
chemins_notes_piano = strcat('Musiques/Notes/Piano/', fichiers_notes_piano);
fichiers_notes_violon = dir('Musiques/Notes/Violon/');
fichiers_notes_violon = {fichiers_notes_violon(3:end).name};
chemins_notes_violon = strcat('Musiques/Notes/Violon/', fichiers_notes_violon);
chemins = [chemins_notes_violon chemins_notes_piano];
D_0 = initialisation_notes(chemins, n_fenetre, n_decalage, fenetre);
A_0 = rand(size(D_0, 2), size(S, 2));
[D, A] = nmf(abs(Y), D_0, A_0, 30, 1, "exo3bis", valeurs_t, valeurs_f, length(chemins_notes_piano));
D_piano = D(:, 1:length(chemins_notes_piano));
D_violon = D(:, length(chemins_notes_piano)+1:end);
A_piano = A(1:length(chemins_notes_piano), :);
A_violon = A(length(chemins_notes_piano)+1:end, :);
Y_final_piano = D_piano * A_piano;
[y_final_piano, ~] = ITFCT(Y_final_piano, f_ech, n_decalage, fenetre);
audiowrite(['/work/lfainsin-matlab/TP12/exo3bis_final_piano.wav'], y_final_piano, f_ech);
Y_final_violon = D_violon * A_violon;
[y_final_violon, ~] = ITFCT(Y_final_violon, f_ech, n_decalage, fenetre);
audiowrite(['/work/lfainsin-matlab/TP12/exo3bis_final_violon.wav'], y_final_violon, f_ech);

18
TP12/initialisation_notes.m Normal file
View file

@ -0,0 +1,18 @@
function D = initialisation_notes(chemins_notes_piano, n_fenetre, n_decalage, fenetre)
D = [];
for i = 1:length(chemins_notes_piano)
chemin = chemins_notes_piano{i};
[y, f_ech] = audioread(chemin);
Y = TFCT(y, f_ech, n_fenetre, n_decalage, fenetre);
S = abs(Y);
D = [ D mean(S, 2) ];
end
end

57
TP12/nmf.m Normal file
View file

@ -0,0 +1,57 @@
function [D_k, A_k] = nmf(S, D_0, A_0, ite, pas, filename, valeurs_t, valeurs_f, R)
delete("/work/lfainsin-matlab/TP12/" + filename + "_sono_" + num2str(R) + ".gif");
delete("/work/lfainsin-matlab/TP12/" + filename + "_dico_" + num2str(R) + ".gif");
delete("/work/lfainsin-matlab/TP12/" + filename + "_activ_" + num2str(R) + ".gif");
figure('units', 'normalized', 'outerposition', [0 0 1 1]);
eps = 10^ - 3;
A_k = A_0 .* max(D_0)';
D_k = D_0 ./ max(D_0);
for i = 1:ite
A_kp1 = A_k .* (D_k' * S) ./ ((D_k' * D_k) * A_k + eps);
D_kp1 = D_k .* (S * A_k') ./ (D_k * (A_k * A_k') + eps);
A_k = A_kp1 .* max(D_kp1)';
D_k = D_kp1 ./ max(D_kp1);
if rem(i, pas) == 0
imagesc(1:R, valeurs_f, 20 * log10(abs(D_k)));
set(gca, 'xtick', 1:R)
caxis([-40 10]);
axis xy;
xlabel('Composantes');
ylabel('Frequence (Hz)');
title("$\mathbf{D_{" + num2str(i) + "}}$", 'Interpreter', 'Latex');
drawnow;
export_fig(gcf, "/work/lfainsin-matlab/TP12/" + filename + "_dico_" + num2str(R) + ".gif", '-png', '-painters', '-m2', '-append', '-delay', 10);
imagesc(valeurs_t, 1:R, A_k);
set(gca, 'ytick', 1:R)
axis xy;
xlabel('Temps (s)');
ylabel('Composantes');
title("$\mathbf{A_{" + num2str(i) + "}}$", 'Interpreter', 'Latex');
drawnow;
export_fig(gcf, "/work/lfainsin-matlab/TP12/" + filename + "_activ_" + num2str(R) + ".gif", '-png', '-painters', '-m2', '-append', '-delay', 10);
prod = 20 * log10(abs(D_k * A_k) + eps);
imagesc(valeurs_t, valeurs_f, prod);
axis xy;
xlabel('Temps (s)');
ylabel('Frequence (Hz)');
title("$\mathbf{S_{" + num2str(i) + "}}$", 'Interpreter', 'Latex');
drawnow;
export_fig(gcf, "/work/lfainsin-matlab/TP12/" + filename + "_sono_" + num2str(R) + ".gif", '-png', '-painters', '-m2', '-append', '-delay', 10);
end
end
end
% ffmpeg -i input.mp3 -ac 1 output.wav

3
TP2/bernstein2.m Normal file
View file

@ -0,0 +1,3 @@
function value = bernstein2(i, d, x)
value = nchoosek(d, i) .* x.^i .* (1-x).^(d-i);
end

7
TP2/bezier.m Normal file
View file

@ -0,0 +1,7 @@
function y = bezier(beta_0,beta,beta_d,x)
d = length(beta)+1;
y = beta_0*(1-x).^d+beta_d*x.^d;
for i = 1:d-1
y = y+beta(i)*nchoosek(d,i)*x.^i.*(1-x).^(d-i);
end

3
TP2/bezier_bruitee.m Normal file
View file

@ -0,0 +1,3 @@
function y = bezier_bruitee(beta_0,beta,beta_d,x,sigma)
y = bezier(beta_0,beta,beta_d,x)+sigma*randn(size(x));

BIN
TP2/bords.mat Normal file
View file

Binary file not shown.

18
TP2/calcul_VC_bis.m Normal file
View file

@ -0,0 +1,18 @@
function VC = calcul_VC_bis(D_app,beta_0,beta_d,d,lambda)
X = D_app(1,:)';
Y = D_app(2,:)';
n = length(X);
VC = 0;
for j=1:n
D_app_loo = [D_app(:,1:j-1) , D_app(:,j+1:n)];
beta = moindres_carres_ecretes(D_app_loo, beta_0, beta_d, d, lambda);
estimation = bezier(beta_0, beta, beta_d, X(j));
VC = VC + (Y(j) - estimation).^2;
end
VC = VC/n;
end

BIN
TP2/donnees.mat Normal file
View file

Binary file not shown.

6
TP2/estimation_lambda_sigma.m Normal file
View file

@ -0,0 +1,6 @@
function [lambda_optimal,sigma_estime] = estimation_lambda_sigma(liste_lambda,liste_VC)
[~, index] = min(liste_VC);
lambda_optimal = liste_lambda(index);
sigma_estime = std(liste_VC);
end

6
TP2/estimation_lois_n.m Normal file
View file

@ -0,0 +1,6 @@
function [moyenne, ecarttype] = estimation_lois_n(X)
moyenne = mean(X);
ecarttype = std(X);
end

60
TP2/exercice_1.m Executable file
View file

@ -0,0 +1,60 @@
clear;
close all;
taille_ecran = get(0,'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
% Calcul du mod<EFBFBD>le exact :
beta_0 = 115;
beta_d = 123;
beta = [133,96,139,118];
n_affichage = 200; % Utilisation de 200 points pour l'affichage
pas_affichage = 1/(n_affichage-1);
x = 0:pas_affichage:1;
y = bezier(beta_0,beta,beta_d,x);
% TracŽ du mod<EFBFBD>le exact (trait noir) :
figure('Name','Estimation ecretee des parametres','Position',[0.4*L,0.05*H,0.6*L,0.7*H]);
plot(x,y,'-k','LineWidth',2);
set(gca,'FontSize',20);
xlabel('$x$','Interpreter','Latex','FontSize',30);
ylabel('$y$','Interpreter','Latex','FontSize',30);
hold on;
% Calcul des donnŽes d'apprentissage (bruit blanc sur les ordonnŽes) :
n_app = 50;
pas_app = 1/(n_app-1);
x_j = 0:pas_app:1;
sigma = 0.5;
y_j = bezier_bruitee(beta_0,beta,beta_d,x_j,sigma);
D_app = [x_j ; y_j];
% TracŽ des donnŽes d'apprentissage (croix bleues) :
plot(x_j,y_j,'+b','MarkerSize',10,'LineWidth',3);
% Param<EFBFBD>tres du mod<EFBFBD>le :
d = 16; % Testez plusieurs valeurs de d entre 2 et 20
% lambda = 0.05; % Testez plusieurs valeurs dans l'intervalle [0,100]
%
% % Estimation des param<EFBFBD>tres de la courbe de BŽzier ˆ partir des donnŽes bruitŽes :
% beta_estime = moindres_carres_ecretes(D_app,beta_0,beta_d,d,lambda);
%
% % TracŽ de la courbe de BŽzier estimŽe, de degrŽ d (trait rouge) :
% y_estime = bezier(beta_0,beta_estime,beta_d,x);
% plot(x,y_estime,'-r','MarkerSize',10,'LineWidth',3);
% lg = legend(' Modele exact',' Donnees d''apprentissage',...
% [' Modele estime ($d=' num2str(d) '$, $\lambda=' num2str(lambda) '$)'],'Location','SouthEast');
% set(lg,'Interpreter','Latex');
lambdas = 0:0.1:1; % Testez plusieurs valeurs dans l'intervalle [0,100]
for lambda=lambdas
% Estimation des param<EFBFBD>tres de la courbe de BŽzier ˆ partir des donnŽes bruitŽes :
beta_estime = moindres_carres_ecretes(D_app,beta_0,beta_d,d,lambda);
% TracŽ de la courbe de BŽzier estimŽe, de degrŽ d (trait rouge) :
y_estime = bezier(beta_0,beta_estime,beta_d,x);
plot(x,y_estime, "DisplayName", num2str(lambda), 'LineWidth',2);
end
legend('Location','SouthEast')

48
TP2/exercice_2.m Executable file
View file

@ -0,0 +1,48 @@
exercice_1;
close all;
% Calcul de la validation croisée Leave-one-out :
d = 16;
liste_lambda = 0.01:0.001:0.11;
tic;
liste_VC = [];
for lambda = liste_lambda
VC = calcul_VC_bis(D_app,beta_0,beta_d,d,lambda);
liste_VC = [liste_VC VC];
end
toc;
% Tracé de la validation croisée Leave-one-out en fonction de lambda :
figure('Name','Estimation de lambda par validation croisee','Position',[0,0.05*H,0.4*L,0.4*H]);
plot(liste_lambda,liste_VC,'sr-','LineWidth',2);
set(gca,'FontSize',20);
xlabel('$\lambda$','Interpreter','Latex','FontSize',30);
ylabel('$VC$','Interpreter','Latex','FontSize',30);
amplitude_VC = max(liste_VC)-min(liste_VC);
axis([min(liste_lambda) max(liste_lambda) min(liste_VC)-0.1*amplitude_VC max(liste_VC)+0.1*amplitude_VC]);
% Estimation de l'hyper-paramètre lambda optimal et de l'écart-type sigma :
[lambda_optimal,sigma_estime] = estimation_lambda_sigma(liste_lambda,liste_VC);
fprintf('Estimation de l''hyper-parametre : lambda = %.3f\n',lambda_optimal);
fprintf('Estimation de l''ecart-type du bruit sur les donnees : %.3f\n',sigma_estime);
% Estimation des paramètres avec la valeur optimale de lambda :
beta_estime = moindres_carres_ecretes(D_app,beta_0,beta_d,d,lambda_optimal);
% Tracé du modèle exact (trait noir) :
figure('Name','Controle de la complexite par regularisation','Position',[0.4*L,0.05*H,0.6*L,0.7*H]);
plot(x,y,'-k','LineWidth',2);
set(gca,'FontSize',20);
xlabel('$x$','Interpreter','Latex','FontSize',30);
ylabel('$y$','Interpreter','Latex','FontSize',30);
hold on;
% Tracé des données d'apprentissage (croix bleues) :
plot(x_j,y_j,'+b','MarkerSize',10,'LineWidth',3);
% Tracé de la courbe de Bézier optimale (trait rouge) :
y_estime = bezier(beta_0,beta_estime,beta_d,x);
plot(x,y_estime,'-r','MarkerSize',10,'LineWidth',3);
lg = legend(' Modele exact',' Donnees d''apprentissage',...
[' Modele optimal pour $d =' num2str(d) '$ ($\lambda=' num2str(lambda_optimal) '$)'],'Location','SouthEast');
set(lg,'Interpreter','Latex');

37
TP2/exercice_3.m Executable file
View file

@ -0,0 +1,37 @@
clear;
close all;
load donnees;
figure('Name','Modelisation de la silhouette par deux courbes de Bezier couplees','Position',[0.4*L,0.05*H,0.6*L,0.7*H]);
% Modélisation de chaque silhouette par deux courbes de Bézier couplées :
d = 5;
X = [];
for k = 1:n
X_estime = moindres_carres_bis(d,y,bords(:,1,k),beta_0,bords(:,2,k),gamma_0);
X_estime_T = transpose(X_estime);
beta_estime = [X_estime_T(1:d-1) X_estime_T(2*d-1)];
gamma_estime = [X_estime_T(d:2*(d-1)) X_estime_T(2*d-1)];
x_gauche = bezier(beta_0,beta_estime(1:end-1),beta_estime(end),y);
x_droite = bezier(gamma_0,gamma_estime(1:end-1),gamma_estime(end),y);
plot(y,bords(:,1,k),'k-','LineWidth',2);
axis(limites);
axis ij;
set(gca,'FontSize',20);
xlabel('$y$','FontSize',30,'Interpreter','Latex');
ylabel('$x$','FontSize',30,'Interpreter','Latex','Rotation',0);
hold on;
plot(y,x_gauche,'r','LineWidth',3);
plot(y,bords(:,2,k),'k-','LineWidth',2);
plot(y,x_droite,'r','LineWidth',3);
plot(1/d:1/d:1, beta_estime, 'x', 'MarkerSize', 10, 'LineWidth',3);
% plot(1/d:1/d:1, gamma_estime, 'x', 'MarkerSize', 10, 'LineWidth',3);
pause(0.5);
hold off;
X = [X ; transpose(X_estime)]; % Stockage dans X de tous les paramètres estimés
end
save exercice_3;

BIN
TP2/exercice_3.mat Normal file
View file

Binary file not shown.

33
TP2/exercice_4.m Executable file
View file

@ -0,0 +1,33 @@
clear;
close all;
load exercice_3;
figure('Name','Simulation d''une flamme de bougie','Position',[0.4*L,0.05*H,0.6*L,0.7*H]);
% Estimation des lois normales :
[moyennes,ecarts_types] = estimation_lois_n(X);
% pause
% Simulation de silhouettes par tirages aléatoires :
N = 40; % Longueur de la sequence simulee
for r = 1:N
[x_gauche,x_droite] = simulation(y,beta_0,gamma_0,moyennes,ecarts_types,d);
if length(find(x_gauche>x_droite))==0
plot(x_droite,y,'Color','r','LineWidth',2);
axis([limites(3:4) limites(1:2)]);
set(gca,'FontSize',20);
xlabel('$y$','FontSize',30,'Interpreter','Latex');
ylabel('$x$','FontSize',30,'Interpreter','Latex','Rotation',0);
hold on;
plot(x_gauche,y,'Color','r','LineWidth',2);
for p = 1:m
plot([x_gauche(p) x_droite(p)],[y(p) y(p)],'Color','r','LineWidth',2);
end
pause(0.1);
hold off;
end
end
save exercice_4;

BIN
TP2/exercice_4.mat Normal file
View file

Binary file not shown.

54
TP2/exercice_5.m Executable file
View file

@ -0,0 +1,54 @@
exercice_1;
close all;
% Calcul rapide de la validation croisée Leave-one-out :
d = 16;
liste_lambda = 0.01:0.001:0.11;
tic;
x_j_T = transpose(D_app(1,:));
y_j_T = transpose(D_app(2,:));
A = [];
for i = 1:d-1
A = [A nchoosek(d,i)*x_j_T.^i.*(1-x_j_T).^(d-i)];
end
liste_VC = [];
for lambda = liste_lambda
VC = calcul_VC_ter(D_app,beta_0,beta_d,d,lambda,A);
liste_VC = [liste_VC VC];
end
toc;
% Tracé de la validation croisée Leave-one-out en fonction de lambda :
figure('Name','Estimation de lambda par validation croisee','Position',[0,0.05*H,0.4*L,0.4*H]);
plot(liste_lambda,liste_VC,'sr-','LineWidth',2);
set(gca,'FontSize',20);
xlabel('$\lambda$','Interpreter','Latex','FontSize',30);
ylabel('$VC$','Interpreter','Latex','FontSize',30);
amplitude_VC = max(liste_VC)-min(liste_VC);
axis([min(liste_lambda) max(liste_lambda) min(liste_VC)-0.1*amplitude_VC max(liste_VC)+0.1*amplitude_VC]);
% Estimation de l'hyper-paramètre lambda optimal et de l'écart-type sigma :
[lambda_optimal,sigma_estime] = estimation_lambda_sigma(liste_lambda,liste_VC);
fprintf('Estimation de l''hyper-parametre : lambda = %.3f\n',lambda_optimal);
fprintf('Estimation de l''ecart-type du bruit sur les donnees : %.3f\n',sigma_estime);
% Estimation des paramètres avec la valeur optimale de lambda :
beta_estime = moindres_carres_ecretes(D_app,beta_0,beta_d,d,lambda_optimal);
% Tracé du modèle exact (trait noir) :
figure('Name','Controle de la complexite par regularisation','Position',[0.4*L,0.05*H,0.6*L,0.7*H]);
plot(x,y,'-k','LineWidth',2);
set(gca,'FontSize',20);
xlabel('$x$','Interpreter','Latex','FontSize',30);
ylabel('$y$','Interpreter','Latex','FontSize',30);
hold on;
% Tracé des données d'apprentissage (croix bleues) :
plot(x_j,y_j,'+b','MarkerSize',10,'LineWidth',3);
% Tracé de la courbe de Bézier optimale (trait rouge) :
y_estime = bezier(beta_0,beta_estime,beta_d,x);
plot(x,y_estime,'-r','MarkerSize',10,'LineWidth',3);
lg = legend(' Modele exact',' Donnees d''apprentissage',...
[' Modele optimal pour $d=' num2str(d) '$ ($\lambda=' num2str(lambda_optimal) '$)'],'Location','SouthEast');
set(lg,'Interpreter','Latex');

16
TP2/moindres_carres_bis.m Normal file
View file

@ -0,0 +1,16 @@
function estimation = moindres_carres_bis(d, y, bords_g, beta_0, bords_d, gamma_0)
x = [bords_g ; bords_d];
F = x - [beta_0 * bernstein2(0, d, y) ; gamma_0 * bernstein2(0, d, y)];
E_block = zeros(length(y), d);
for i=1:d
E_block(:,i) = bernstein2(i, d, y);
end
E = [E_block(:,1:d-1) zeros(length(y), d-1) E_block(:,d) ; zeros(length(y), d-1) E_block];
estimation = E \ F;
end

16
TP2/moindres_carres_ecretes.asv Normal file
View file

@ -0,0 +1,16 @@
function estimation = moindres_carres_ecretes(D_app,beta_0,beta_d,d,lambda)
X = D_app(1,:)';
Y = D_app(2,:)';
[A, B, beta_chapeau] = moindres_carres(D_app, beta_0, beta_d, d);
slope = (beta_d - beta_0) / (X(length(X)) - X(1));
beta_barre = slope*X + beta_0;
C = B - A * beta_chapeau';
delta_chapeau = (A' * A + lambda * eye(d-1)) \ A' * C
end

22
TP2/moindres_carres_ecretes.m Normal file
View file

@ -0,0 +1,22 @@
function estimation = moindres_carres_ecretes(D_app, beta_0, beta_d, d, lambda)
X = D_app(1, :)';
Y = D_app(2, :)';
B = Y - beta_0 * (1 - X).^d - beta_d * (X.^d);
A = zeros(length(X), d - 1);
for i = 1:(d - 1)
A(:, i) = nchoosek(d, i) .* X.^i .* (1 - X).^(d - i);
end
slope = (beta_d - beta_0) / (X(length(X)) - X(1));
beta_barre = slope * (1 / d:1 / d:1 - 1 / d)' + beta_0;
C = B - A * beta_barre;
delta_chapeau = (A' * A + lambda * eye(d - 1)) \ (A' * C);
estimation = beta_barre + delta_chapeau;
end

43
TP2/nouveau_parametrage.m Executable file
View file

@ -0,0 +1,43 @@
clear;
close all;
taille_ecran = get(0,'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
% Calcul du mod<EFBFBD>le exact :
beta_0 = 115;
beta_d = 123;
beta = [133,96,139,118];
n_affichage = 200; % Utilisation de 200 points pour l'affichage
pas_affichage = 1/(n_affichage-1);
x = 0:pas_affichage:1;
y = bezier(beta_0,beta,beta_d,x);
% TracŽ du mod<EFBFBD>le exact (trait noir) :
figure('Name','parametres adaptes a la regularisation','Position',[0.4*L,0.05*H,0.6*L,0.7*H]);
plot(x,y,'-k','LineWidth',2);
set(gca,'FontSize',20);
xlabel('$x$','Interpreter','Latex','FontSize',30);
ylabel('$y$','Interpreter','Latex','FontSize',30);
hold on;
% Affichage des points de contr™le (disques noirs) :
d = length(beta)+1;
alpha_0 = 0;
alpha_d = 1;
alpha = [1:d-1]/d;
plot([alpha_0 alpha alpha_d],[beta_0 beta beta_d],'ok','MarkerFaceColor','k','MarkerSize',10,'LineWidth',3);
% TracŽ de la droite reliant les points de contr™le extr<EFBFBD>mes (trait bleu) :
line([alpha_0 alpha_d],[beta_0 beta_d],'Color','b','LineWidth',3);
% Affichage des projections verticales des points de contr™le sur cette droite (disques bleus) :
beta_barre = beta_0+(beta_d-beta_0)*alpha;
plot(alpha,beta_barre,'ob','MarkerFaceColor','b','MarkerSize',10,'LineWidth',3);
% MatŽrialisation des Žcarts (pointillŽs noirs) :
for i = 1:d-1
plot([alpha(i),alpha(i)],[beta(i),beta_barre(i)],'--k','LineWidth',2)
end
legend(' Modele exact',' Points de controle du modele exact',...
' Modele simplifie',' Points de controle du modele simplifie','Location','SouthEast');

42
TP2/sequence_flammes.m Executable file
View file

@ -0,0 +1,42 @@
clear;
close all;
load exercice_4;
load texture;
figure('Name','Simulation d''une flamme de bougie','Position',[0.4*L,0.05*H,0.6*L,0.7*H]);
% Estimation des lois normales :
[moyennes,ecarts_types] = estimation_lois_n(X);
% Simulation de flammes :
I_max = 255;
[nb_lignes_texture,nb_colonnes_texture] = size(texture);
largeur = 1000; % Largeur de l'image
echelle_en_largeur = 0.5*largeur/(limites(4)-limites(3));
hauteur = 1000; % Hauteur de l'image
h = round(0.85*hauteur); % Hauteur de la flamme
y = 0:1/(h-1):1; % Ordonnées normalisées entre 0 et 1
x_centre = (beta_0+gamma_0)/2; % Abscisse du centre de la flamme
N = 40; % Longueur de la séquence
for r = 1:N
I = zeros(hauteur,largeur);
[x_gauche,x_droite] = simulation(y,beta_0,gamma_0,moyennes,ecarts_types,d);
if length(find(x_gauche>x_droite))==0
for j = 1:h
num_ligne_texture = round((nb_lignes_texture*(h-j)+j-1)/(h-1));
num_colonne_image_min = floor(largeur/2+echelle_en_largeur*(x_gauche(j)-x_centre));
num_colonne_image_max = ceil(largeur/2+echelle_en_largeur*(x_droite(j)-x_centre));
largeur_flamme = num_colonne_image_max-num_colonne_image_min;
for num_colonne_image = max(num_colonne_image_min,1):min(num_colonne_image_max,largeur)
colonne_texture = round((num_colonne_image-num_colonne_image_min)*(nb_colonnes_texture-1)/largeur_flamme+1);
I(j,num_colonne_image) = round(texture(num_ligne_texture,colonne_texture)*I_max);
end
end
imagesc(I);
axis xy;
axis off;
colormap(hot); % Table de couleurs donnant des couleurs chaudes (doc colormap)
pause(0.1);
end
end

17
TP2/simulation.m Normal file
View file

@ -0,0 +1,17 @@
function [x_gauche,x_droite] = simulation(y,beta_0,gamma_0,moyennes,ecarts_types,d)
beta = ecarts_types(1:d-1) .* randn(d-1, 1) + moyennes(1:d-1);
% beta = ecarts_types(1:d-1) .* randn(1, d-1) + moyennes(1:d-1)
gamma = ecarts_types(d:2*d-2) .* randn(d-1, 1) + moyennes(d:2*d-2);
% gamma = ecarts_types(d:2*d-2) .* randn(1, d-1) + moyennes(d:2*d-2);
gamma_d = ecarts_types(2*d-1) * randn() + moyennes(2*d-1);
beta_d = gamma_d;
x_gauche = bezier(beta_0, beta, beta_d, y);
x_droite = bezier(gamma_0, gamma, gamma_d, y);
% close all;
% pause
end

BIN
TP2/texture.mat Normal file
View file

Binary file not shown.

18
TP3/calcul_r.m Normal file
View file

@ -0,0 +1,18 @@
function r = calcul_r(D_app, parametres)
a = parametres(1);
e = parametres(2);
x_C = parametres(3);
y_C = parametres(4);
theta = parametres(5);
e_carre = e^2;
b_carre = a^2*(1-e_carre);
R = [cos(theta) -sin(theta) ; sin(theta) cos(theta)];
D_app = transpose(R)*(D_app-[x_C;y_C]*ones(1,size(D_app,2)));
x = D_app(1,:);
y = D_app(2,:);
rho = sqrt(x.^2+y.^2);
cos_angle = cos(atan(y./x));
rho_ellipse = sqrt(b_carre./(1-e_carre*cos_angle.^2));
r = rho-rho_ellipse;

52
TP3/calcul_score.m Normal file
View file

@ -0,0 +1,52 @@
function score = calcul_score(parametres_VT,parametres_estim)
a_VT = parametres_VT(1);
e_VT = parametres_VT(2);
c_VT = a_VT*e_VT;
x_C_VT = parametres_VT(3);
y_C_VT = parametres_VT(4);
theta_VT = parametres_VT(5);
cos_VT = cos(theta_VT);
sin_VT = sin(theta_VT);
x_F1_VT = x_C_VT+c_VT*cos_VT;
y_F1_VT = y_C_VT+c_VT*sin_VT;
x_F2_VT = x_C_VT-c_VT*cos_VT;
y_F2_VT = y_C_VT-c_VT*sin_VT;
a_estim = parametres_estim(1);
e_estim = parametres_estim(2);
c_estim = a_estim*e_estim;
x_C_estim = parametres_estim(3);
y_C_estim = parametres_estim(4);
theta_estim = parametres_estim(5);
cos_estim = cos(theta_estim);
sin_estim = sin(theta_estim);
x_F1_estim = x_C_estim+c_estim*cos_estim;
y_F1_estim = y_C_estim+c_estim*sin_estim;
x_F2_estim = x_C_estim-c_estim*cos_estim;
y_F2_estim = y_C_estim-c_estim*sin_estim;
a_max = max(a_VT,a_estim);
x_min = floor(min([x_F1_VT,x_F2_VT,x_F1_estim,x_F2_estim])-a_max);
x_max = ceil(max([x_F1_VT,x_F2_VT,x_F1_estim,x_F2_estim])+a_max);
y_min = floor(min([y_F1_VT,y_F2_VT,y_F1_estim,y_F2_estim])-a_max);
y_max = ceil(max([y_F1_VT,y_F2_VT,y_F1_estim,y_F2_estim])+a_max);
pas_echantillonnage = 0.25;
[X,Y] = meshgrid(x_min:pas_echantillonnage:x_max,y_min:pas_echantillonnage:y_max);
d_P_F1_VT = sqrt((X-x_F1_VT).^2+(Y-y_F1_VT).^2);
d_P_F2_VT = sqrt((X-x_F2_VT).^2+(Y-y_F2_VT).^2);
d_P_F1_estim = sqrt((X-x_F1_estim).^2+(Y-y_F1_estim).^2);
d_P_F2_estim = sqrt((X-x_F2_estim).^2+(Y-y_F2_estim).^2);
indices_union = find(d_P_F1_VT+d_P_F2_VT<2*a_VT | d_P_F1_estim+d_P_F2_estim<2*a_estim);
indices_inter = find(d_P_F1_VT+d_P_F2_VT<2*a_VT & d_P_F1_estim+d_P_F2_estim<2*a_estim);
union = length(indices_union(:));
inter = length(indices_inter(:));
score = inter/union;

11
TP3/calcul_score_2.m Normal file
View file

@ -0,0 +1,11 @@
function score = calcul_score_2(parametres_1_VT,parametres_2_VT,parametres_1_estim,parametres_2_estim)
score_1_1 = calcul_score(parametres_1_VT,parametres_1_estim);
score_2_2 = calcul_score(parametres_2_VT,parametres_2_estim);
score_sans_echange = (score_1_1+score_2_2)/2;
score_2_1 = calcul_score(parametres_2_VT,parametres_1_estim);
score_1_2 = calcul_score(parametres_1_VT,parametres_2_estim);
score_avec_echange = (score_2_1+score_1_2)/2;
score = max(score_sans_echange,score_avec_echange);

35
TP3/conversion.m Normal file
View file

@ -0,0 +1,35 @@
function parametres = conversion(X)
alpha = X(1);
beta = X(2);
gamma = X(3);
delta = X(4);
epsilon = X(5);
phi = X(6);
% Calcul de l'angle theta :
theta = 1/2*atan(beta/(alpha-gamma));
c = cos(theta);
s = sin(theta);
% Calcul de la position du centre :
M = [2*alpha*c+beta*s 2*gamma*s+beta*c ; -2*alpha*s+beta*c 2*gamma*c-beta*s];
C = -inv(M)*[delta*c+epsilon*s ; -delta*s+epsilon*c];
x_C = C(1);
y_C = C(2);
% Calcul des demi-axes :
degre_0 = alpha*x_C^2+beta*x_C*y_C+gamma*y_C^2+delta*x_C+epsilon*y_C+phi;
a = sqrt(-degre_0/(alpha*c^2+beta*s*c+gamma*s^2));
b = sqrt(-degre_0/(alpha*s^2-beta*s*c+gamma*c^2));
% On force a>=b :
if b>a
theta = theta+pi/2;
aux = a;
a = b;
b = aux;
end
e = sqrt(1-b^2/a^2);
parametres = [a,e,x_C,y_C,theta];

45
TP3/donnees.m Normal file
View file

@ -0,0 +1,45 @@
clear;
close all;
taille_ecran = get(0,'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
% Paramètres :
taille = 20;
echelle = [-taille taille -taille taille];
% Tirage aléatoire des paramètres de l'ellipse :
a = 2*taille/5*(rand+1); % Demi grand axe
e = 0.9*rand; % Excentricité
x_C = (taille-a)*(2*rand-1); % Abscisse du centre
y_C = (taille-a)*(2*rand-1); % Ordonnée du centre
theta = 2*pi*rand; % Angle du grand axe
b = a*sqrt(1-e^2);
R = [cos(theta) -sin(theta) ; sin(theta) cos(theta)];
parametres_VT = [a,e,x_C,y_C,theta];
% Tracé de l'ellipse (trait noir) :
figure('Name','Donnees d''apprentissage','Position',[0,0,0.33*L,0.5*H]);
n_affichage = 100;
theta_affichage = 2*pi/n_affichage:2*pi/n_affichage:2*pi;
P = R*[a*cos(theta_affichage);b*sin(theta_affichage)]+[x_C;y_C]*ones(1,n_affichage);
x = P(1,:);
y = P(2,:);
plot([x x(1)],[y y(1)],'k-','LineWidth',3);
set(gca,'FontSize',20);
xlabel('$x$','Interpreter','Latex','FontSize',30);
ylabel('$y$','Interpreter','Latex','FontSize',30);
axis([-taille taille -taille taille]);
axis equal;
hold on;
% Calcul des données d'apprentissage (bruit blanc sur x et sur y) :
n_app = 100;
sigma = 1;
% sigma = 0;
theta_app = 2*pi*rand(1,n_app);
D_app = R*[a*cos(theta_app);b*sin(theta_app)]+[x_C;y_C]*ones(1,n_app)+sigma*randn(2,n_app);
% Tracé des données d'apprentissage (croix bleues) :
plot(D_app(1,:),D_app(2,:),'+b','MarkerSize',10,'LineWidth',2);
legend(' Ellipse initiale',' Donnees d''apprentissage','Location','Best');

63
TP3/donnees_2.m Normal file
View file

@ -0,0 +1,63 @@
clear;
close all;
taille_ecran = get(0,'ScreenSize');
L = taille_ecran(3);
H = taille_ecran(4);
% Paramètres :
taille = 20;
echelle = [-taille taille -taille taille];
% Tirage aléatoire des paramètres de la première ellipse :
a_1 = 2*taille/5*(rand+1); % Demi grand axe
e_1 = 0.9*rand; % Excentricité
x_C_1 = (taille-a_1)*(2*rand-1); % Abscisse du centre
y_C_1 = (taille-a_1)*(2*rand-1); % Ordonnée du centre
theta_1 = 2*pi*rand; % Angle du grand axe
b_1 = a_1*sqrt(1-e_1^2);
R_1 = [cos(theta_1) -sin(theta_1) ; sin(theta_1) cos(theta_1)];
parametres_1_VT = [a_1,e_1,x_C_1,y_C_1,theta_1];
% Tracé de la première ellipse (trait noir) :
figure('Name','Donnees d''apprentissage','Position',[0,0,0.33*L,0.5*H]);
n_affichage = 100;
theta_affichage = 2*pi/n_affichage:2*pi/n_affichage:2*pi;
P_1 = R_1*[a_1*cos(theta_affichage);b_1*sin(theta_affichage)]+[x_C_1;y_C_1]*ones(1,n_affichage);
x_1 = P_1(1,:);
y_1 = P_1(2,:);
h = zeros(1,3);
h(1) = plot([x_1 x_1(1)],[y_1 y_1(1)],'k-','LineWidth',3);
set(gca,'FontSize',20);
xlabel('$x$','Interpreter','Latex','FontSize',30);
ylabel('$y$','Interpreter','Latex','FontSize',30);
axis([-taille taille -taille taille]);
axis equal;
hold on;
% Tirage aléatoire des paramètres de la deuxième ellipse :
a_2 = 2*taille/5*(rand+1); % Demi grand axe
e_2 = 0.9*rand; % Excentricité
x_C_2 = (taille-a_2)*(2*rand-1); % Abscisse du centre
y_C_2 = (taille-a_2)*(2*rand-1); % Ordonnée du centre
theta_2 = 2*pi*rand; % Angle du grand axe
b_2 = a_2*sqrt(1-e_2^2);
R_2 = [cos(theta_2) -sin(theta_2) ; sin(theta_2) cos(theta_2)];
parametres_2_VT = [a_2,e_2,x_C_2,y_C_2,theta_2];
% Tracé de la deuxième ellipse (trait noir) :
P_2 = R_2*[a_2*cos(theta_affichage);b_2*sin(theta_affichage)]+[x_C_2;y_C_2]*ones(1,n_affichage);
x_2 = P_2(1,:);
y_2 = P_2(2,:);
h(2) = plot([x_2 x_2(1)],[y_2 y_2(1)],'k-','LineWidth',3);
% Calcul des données d'apprentissage (bruit blanc sur x et sur y) :
n_app = 100;
sigma = 1;
theta_app = 2*pi*rand(1,n_app);
D_app_1 = R_1*[a_1*cos(theta_app);b_1*sin(theta_app)]+[x_C_1;y_C_1]*ones(1,n_app)+sigma*randn(2,n_app);
D_app_2 = R_2*[a_2*cos(theta_app);b_2*sin(theta_app)]+[x_C_2;y_C_2]*ones(1,n_app)+sigma*randn(2,n_app);
D_app = [D_app_1 D_app_2];
% Tracé des données d'apprentissage (croix bleues) :
h(3) = plot(D_app(1,:),D_app(2,:),'+b','MarkerSize',10,'LineWidth',2);
legend(h(2:3),' Ellipses initiales',' Donnees d''apprentissage','Location','Best');

33
TP3/exercice_1.m Executable file
View file

@ -0,0 +1,33 @@
donnees;
drawnow;
% Trac<EFBFBD> des donn<EFBFBD>es d'apprentissage (croix bleues) :
figure('Name','Estimation par le maximum de vraisemblance','Position',[0.33*L,0,0.33*L,0.5*H]);
plot(D_app(1,:),D_app(2,:),'+b','MarkerSize',10,'LineWidth',2);
set(gca,'FontSize',20);
xlabel('$x$','Interpreter','Latex','FontSize',30);
ylabel('$y$','Interpreter','Latex','FontSize',30);
axis([-taille taille -taille taille]);
axis equal;
hold on;
% Tirages al<EFBFBD>atoires de param<EFBFBD>tres pour l'ellipse :
nb_tirages = 10000;
parametres_test = zeros(nb_tirages,5);
parametres_test(:,1) = 2*taille/5*(rand(nb_tirages,1)+1); % Demi-grand axe
parametres_test(:,2) = rand(nb_tirages,1); % Excentricit<EFBFBD>
parametres_test(:,3) = (3*taille/5)*(2*rand(nb_tirages,1)-1); % Abscisse du centre
parametres_test(:,4) = (3*taille/5)*(2*rand(nb_tirages,1)-1); % Ordonn<EFBFBD>e du centre
parametres_test(:,5) = 2*pi*rand(nb_tirages,1); % Angle du grand axe
% Estimation de l'ellipse par le maximum de vraisemblance :
parametres_MV = max_vraisemblance(D_app,parametres_test);
% Trac<EFBFBD> de l'ellipse estim<EFBFBD>e par le maximum de vraisemblance (trait rouge) :
[x_MV,y_MV] = points_ellipse(parametres_MV,theta_affichage);
plot([x_MV x_MV(1)],[y_MV y_MV(1)],'r-','LineWidth',3);
legend(' Donnees d''apprentissage',' Ellipse estimee par MV','Location','Best');
% Calcul et affichage du score :
score_MV = calcul_score(parametres_VT,parametres_MV);
fprintf('Score de l''estimation par MV : %.3f\n',score_MV);

45
TP3/exercice_2.m Executable file
View file

@ -0,0 +1,45 @@
donnees;
drawnow;
% TracŽ des donnŽes d'apprentissage (croix bleues) :
figure('Name','Estimation par les moindres carres','Position',[0.33*L,0,0.33*L,0.5*H]);
plot(D_app(1,:),D_app(2,:),'+b','MarkerSize',10,'LineWidth',2);
set(gca,'FontSize',20);
xlabel('$x$','Interpreter','Latex','FontSize',30);
ylabel('$y$','Interpreter','Latex','FontSize',30);
axis([-taille taille -taille taille]);
axis equal;
hold on;
% Tirages alŽatoires de param<EFBFBD>tres pour l'ellipse :
nb_tirages = 10000;
parametres_test = zeros(nb_tirages,5);
parametres_test(:,1) = 2*taille/5*(rand(nb_tirages,1)+1); % Demi-grand axe
parametres_test(:,2) = rand(nb_tirages,1); % ExcentricitŽ
parametres_test(:,3) = (3*taille/5)*(2*rand(nb_tirages,1)-1); % Abscisse du centre
parametres_test(:,4) = (3*taille/5)*(2*rand(nb_tirages,1)-1); % OrdonnŽe du centre
parametres_test(:,5) = 2*pi*rand(nb_tirages,1); % Angle du grand axe
% Estimation de l'ellipse par le maximum de vraisemblance :
parametres_MV = max_vraisemblance(D_app,parametres_test);
% TracŽ de l'ellipse estimŽe par le maximum de vraisemblance (trait rouge) :
[x_MV,y_MV] = points_ellipse(parametres_MV,theta_affichage);
plot([x_MV x_MV(1)],[y_MV y_MV(1)],'r-','LineWidth',3);
% Calcul et affichage du score :
score_MV = calcul_score(parametres_VT,parametres_MV);
fprintf('Score de l''estimation par MV : %.3f\n',score_MV);
% Estimation en moindres carrŽs :
X = moindres_carres(D_app);
parametres_MC = conversion(X);
% TracŽ de l'ellipse estimŽe en moindres carrŽs (trait vert) :
[x_MC,y_MC] = points_ellipse(parametres_MC,theta_affichage);
plot([x_MC x_MC(1)],[y_MC y_MC(1)],'g-','LineWidth',3);
% Calcul et affichage du score :
score_MC = calcul_score(parametres_VT,parametres_MC);
fprintf('Score de l''estimation par MC : %.3f\n',score_MC);
legend(' Donnees d''apprentissage',' Ellipse estimee par MV',' Ellipse estimee par MC','Location','Best');

79
TP3/exercice_3.m Normal file
View file

@ -0,0 +1,79 @@
donnees_2;
drawnow;
% Tracé des données d'apprentissage (croix bleues) :
figure('Name','Estimation par le maximum de vraisemblance','Position',[0.33*L,0,0.33*L,0.5*H]);
h = zeros(1,3);
h(1) = plot(D_app(1,:),D_app(2,:),'+b','MarkerSize',10,'LineWidth',2);
set(gca,'FontSize',20);
xlabel('$x$','Interpreter','Latex','FontSize',30);
ylabel('$y$','Interpreter','Latex','FontSize',30);
axis([-taille taille -taille taille]);
axis equal;
hold on;
% Tirages aléatoires de paramètres pour la paire d'ellipses :
nb_tirages = 20000;
parametres_test = zeros(nb_tirages,2,5);
parametres_test(:,:,1) = 2*taille/5*(rand(nb_tirages,2)+1); % Demi-grand axe
parametres_test(:,:,2) = rand(nb_tirages,2); % Excentricité
parametres_test(:,:,3) = (3*taille/5)*(2*rand(nb_tirages,2)-1); % Abscisse du centre
parametres_test(:,:,4) = (3*taille/5)*(2*rand(nb_tirages,2)-1); % Ordonnée du centre
parametres_test(:,:,5) = 2*pi*rand(nb_tirages,2); % Angle du grand axe
% Estimation d'une paire d'ellipses par le maximum de vraisemblance :
parametres_estim = max_vraisemblance_2(D_app,parametres_test,sigma);
parametres_estim = reshape(parametres_estim,2,5);
parametres_1_estim = parametres_estim(1,:);
parametres_2_estim = parametres_estim(2,:);
% Tracé des ellipses estimées par le maximum de vraisemblance (trait rouge) :
[x_1,y_1] = points_ellipse(parametres_1_estim,theta_affichage);
h(2) = plot([x_1 x_1(1)],[y_1 y_1(1)],'r-','LineWidth',3);
[x_2,y_2] = points_ellipse(parametres_2_estim,theta_affichage);
h(3) = plot([x_2 x_2(1)],[y_2 y_2(1)],'r-','LineWidth',3);
legend(h(1:2),' Donnees d''apprentissage',' Ellipses estimees','Location','Best');
drawnow;
% Calcul et affichage du score :
score = calcul_score_2(parametres_1_VT,parametres_2_VT,parametres_1_estim,parametres_2_estim);
fprintf('Score de l''estimation par MV : %.3f\n',score);
% Calcul des probabilités d'appartenance aux deux classes :
probas = probabilites(D_app,parametres_estim,sigma);
probas_classe_1 = probas(1,:);
probas_classe_2 = probas(2,:);
% Partition des données :
classe_1 = find(probas_classe_1>=probas_classe_2);
classe_2 = find(probas_classe_1<probas_classe_2);
D_app_1 = D_app(:,classe_1);
D_app_2 = D_app(:,classe_2);
% Affichage de la partition (croix bleues et vertes) :
figure('Name','Estimation par les moindres carres','Position',[0.66*L,0,0.33*L,0.5*H]);
plot(D_app_1(1,:),D_app_1(2,:),'+b','MarkerSize',10,'LineWidth',2);
set(gca,'FontSize',20);
xlabel('$x$','Interpreter','Latex','FontSize',30);
ylabel('$y$','Interpreter','Latex','FontSize',30);
axis([-taille taille -taille taille]);
axis equal;
hold on;
plot(D_app_2(1,:),D_app_2(2,:),'+g','MarkerSize',10,'LineWidth',2);
% Estimation en moindres carrés :
X_1 = moindres_carres(D_app_1);
parametres_1_estim = conversion(X_1);
X_2 = moindres_carres(D_app_2);
parametres_2_estim = conversion(X_2);
% Tracé des ellipses estimées en moindres carrés (traits bleu et vert) :
[x_1,y_1] = points_ellipse(parametres_1_estim,theta_affichage);
plot([x_1 x_1(1)],[y_1 y_1(1)],'b-','LineWidth',3);
[x_2,y_2] = points_ellipse(parametres_2_estim,theta_affichage);
plot([x_2 x_2(1)],[y_2 y_2(1)],'g-','LineWidth',3);
legend(' Classe 1',' Classe 2',' Ellipse estimee 1',' Ellipse estimee 2','Location','Best');
% Calcul et affichage du score :
score = calcul_score_2(parametres_1_VT,parametres_2_VT,parametres_1_estim,parametres_2_estim);
fprintf('Score de l''estimation par MC : %.3f\n',score);

61
TP3/exercice_4.m Normal file
View file

@ -0,0 +1,61 @@
exercice_3;
% Valeurs initiales des proportions :
proportion_1 = size(D_app_1,2)/size(D_app,2);
proportion_2 = 1-proportion_1;
% Algorithme EM :
difference_score = 1;
seuil = 0.0001;
while abs(difference_score)>seuil
% Calcul des probabilités d'appartenance aux deux classes :
parametres_estim = [parametres_1_estim ; parametres_2_estim];
probas = probabilites_EM(D_app,parametres_estim,proportion_1,proportion_2,sigma);
probas_1 = probas(1,:);
probas_2 = probas(2,:);
% Partition des données :
classe_1 = find(probas_1>=probas_2);
classe_2 = find(probas_1<probas_2);
D_app_1 = D_app(:,classe_1);
D_app_2 = D_app(:,classe_2);
% Affichage de la partition :
hold off;
plot(D_app_1(1,:),D_app_1(2,:),'+b','MarkerSize',10,'LineWidth',2);
set(gca,'FontSize',20);
xlabel('$x$','Interpreter','Latex','FontSize',30);
ylabel('$y$','Interpreter','Latex','FontSize',30);
axis([-taille taille -taille taille]);
axis equal;
hold on;
plot(D_app_2(1,:),D_app_2(2,:),'+g','MarkerSize',10,'LineWidth',2);
% Mise à jour des proportions :
proportion_1 = mean(probas_1);
proportion_2 = 1-proportion_1;
% Estimation en moindres carrés pondérés :
X_1 = moindres_carres_ponderes(D_app,probas_1);
parametres_1_estim = conversion(X_1);
X_2 = moindres_carres_ponderes(D_app,probas_2);
parametres_2_estim = conversion(X_2);
% Tracé des ellipses estimées en moindres carrés (traits bleu et vert) :
[x_1,y_1] = points_ellipse(parametres_1_estim,theta_affichage);
plot([x_1 x_1(1)],[y_1 y_1(1)],'b-','LineWidth',3);
[x_2,y_2] = points_ellipse(parametres_2_estim,theta_affichage);
plot([x_2 x_2(1)],[y_2 y_2(1)],'g-','LineWidth',3);
legend(' Classe 1',' Classe 2',' Ellipse 1',' Ellipse 2','Location','Best');
% Calcul du nouveau score :
score_nouv = calcul_score_2(parametres_1_VT,parametres_2_VT,parametres_1_estim,parametres_2_estim);
difference_score = score_nouv-score;
score = score_nouv;
pause(0.5);
end
% Affichage du score final :
fprintf('Score de l''estimation par EM : %.3f\n',score);

13
TP3/max_vraisemblance.m Normal file
View file

@ -0,0 +1,13 @@
function parametres_MV = max_vraisemblance(D_app, parametres_test)
parametres_test
nb_tirages = length(parametres_test);
R = zeros(nb_tirages, 1);
[~, index] = min(R);
parametres_MV = parametres_test(index,:);
end

Some files were not shown because too many files have changed in this diff Show more