diff options
| author | Vivien Kraus <vivien@planete-kraus.eu> | 2021-04-07 12:05:36 +0200 |
|---|---|---|
| committer | Vivien Kraus <vivien@planete-kraus.eu> | 2021-06-15 13:34:18 +0200 |
| commit | bb1ae75c56d34a65662d7b285333c595c0ddae7f (patch) | |
| tree | e8baf732ce062603f0982ebc093fbd5451c45e65 | |
Nouvelle version du manuscrit avec HTML
43 files changed, 11875 insertions, 0 deletions
diff --git a/Makefile.am b/Makefile.am new file mode 100644 index 0000000..db2e6c6 --- /dev/null +++ b/Makefile.am @@ -0,0 +1,96 @@ +FIGURE_SOURCES = \ + images/twomoons.R \ + images/l21m2.R \ + images/insurance_rmse.R \ + images/insurance_mae.R \ + images/lsmr_local_scpf.R \ + images/lsmr_local_osales.R \ + images/lsmr_local_sf2.R \ + images/lsmr_local_oes97.R \ + images/wilcoxon.R \ + images/nemenyi.R \ + images/rsms_1.R \ + images/rsms_2.R \ + images/rsms_3.R \ + images/rsms_4.R \ + images/featureselectionlizeo.R \ + images/featureselectionlizeofull.R + +OTHER_FIGURES = \ + images/fig-multi-vues.svg \ + images/fig-co-training.svg \ + images/lasso.svg \ + images/dirty.svg \ + images/hireaugramme.png \ + images/hireau-s.png \ + images/bothsemimulti.svg \ + images/lizeo-donnees.png \ + images/lizeoclassif.svg \ + images/lizeoreg.svg \ + images/lsmrrsmsapprentissage.svg \ + images/lsmrrsmsinference.svg + +dist_noinst_SCRIPTS = $(FIGURE_SOURCES) + +pdf_DATA = manuscrit.pdf + +EXTRA_DIST = \ + manuscrit.html \ + images/logo.png \ + manuscrit.xsl \ + page-de-garde.xsl \ + $(OTHER_FIGURES) \ + images/laps3l_graph_code.R \ + data/laps3l_tuning.Rdata \ + images/lsmr_local_tuning.R \ + data/lsmr_local_tuning.Rdata \ + images/lsmr_global_tuning.R \ + data/lsmr_global_tuning.Rdata \ + data/rsms_test.Rdata \ + data/rsms_protocol_4.Rdata \ + data/feature_selection_lizeo.Rdata + +CLEANFILES = \ + manuscrit.{tex,bib,aux,bbl,blg,loa,lof,log,lot,out,pdf,toc} \ + page-de-garde.{aux,log,tex,pdf} \ + $(FIGURE_SOURCES:.R=.svg) \ + images/the-logo.png \ + Rplots.pdf + +.PHONY: all clean-local + +all: manuscrit.pdf + +manuscrit.pdf: manuscrit.tex manuscrit.bib page-de-garde.pdf $(FIGURE_SOURCES:.R=.svg) $(OTHER_FIGURES) + HOME="$$PWD/inkscape-home" $(PDFLATEX) -shell-escape -interaction nonstopmode $< + $(BIBTEX) manuscrit + HOME="$$PWD/inkscape-home" $(PDFLATEX) -shell-escape -interaction nonstopmode $< + HOME="$$PWD/inkscape-home" $(PDFLATEX) -shell-escape -interaction nonstopmode $< + +page-de-garde.pdf: page-de-garde.tex images/the-logo.png + $(PDFLATEX) -shell-escape -interaction nonstopmode $< + $(PDFLATEX) -shell-escape -interaction nonstopmode $< + +images/the-logo.png: images/logo.png + mkdir -p images + cp $< $@ + +manuscrit.tex: manuscrit.xsl manuscrit.html + $(XSLTPROC) $^ > $@-t + mv $@-t $@ + +page-de-garde.tex: page-de-garde.xsl manuscrit.html + $(XSLTPROC) $^ > $@-t + mv $@-t $@ + +manuscrit.bib: manuscrit.html + $(XSLTPROC) 'http://h4sp.planete-kraus.eu/transform/bibliography.xsl' $< > $@-t + mv $@-t $@ + +%.svg: %.R + mkdir -p images + export ABS_TOP_SRCDIR="@abs_top_srcdir@" OUTPUT=$@-t; $(RSCRIPT) $< + mv $@-t $@ + +clean-local: + rm -rf svg-inkscape inkscape-home diff --git a/configure.ac b/configure.ac new file mode 100644 index 0000000..f3d9c44 --- /dev/null +++ b/configure.ac @@ -0,0 +1,24 @@ +# -*- Autoconf -*- +# Process this file with autoconf to produce a configure script. + +AC_PREREQ([2.69]) +AC_INIT([manuscript], [SNAPSHOT], [vivien@planete-kraus.eu]) +AM_INIT_AUTOMAKE([foreign]) + +# Checks for programs. +AC_PROG_INSTALL +AM_MISSING_PROG([RSCRIPT], [Rscript]) +AM_MISSING_PROG([PDFLATEX], [pdflatex]) +AM_MISSING_PROG([BIBTEX], [bibtex]) +AM_MISSING_PROG([XSLTPROC], [xsltproc]) + +# Checks for libraries. + +# Checks for header files. + +# Checks for typedefs, structures, and compiler characteristics. + +# Checks for library functions. + +AC_CONFIG_FILES([Makefile]) +AC_OUTPUT diff --git a/data/feature_selection_lizeo.Rdata b/data/feature_selection_lizeo.Rdata Binary files differnew file mode 100644 index 0000000..86a1d09 --- /dev/null +++ b/data/feature_selection_lizeo.Rdata diff --git a/data/laps3l_tuning.Rdata b/data/laps3l_tuning.Rdata Binary files differnew file mode 100644 index 0000000..87cf740 --- /dev/null +++ b/data/laps3l_tuning.Rdata diff --git a/data/lsmr_global_tuning.Rdata b/data/lsmr_global_tuning.Rdata Binary files differnew file mode 100644 index 0000000..e425854 --- /dev/null +++ b/data/lsmr_global_tuning.Rdata diff --git a/data/lsmr_local_tuning.Rdata b/data/lsmr_local_tuning.Rdata Binary files differnew file mode 100644 index 0000000..5c0dfc5 --- /dev/null +++ b/data/lsmr_local_tuning.Rdata diff --git a/data/rsms_protocol_4.Rdata b/data/rsms_protocol_4.Rdata Binary files differnew file mode 100644 index 0000000..c5f76ea --- /dev/null +++ b/data/rsms_protocol_4.Rdata diff --git a/data/rsms_test.Rdata b/data/rsms_test.Rdata Binary files differnew file mode 100644 index 0000000..7595706 --- /dev/null +++ b/data/rsms_test.Rdata diff --git a/images/bothsemimulti.svg b/images/bothsemimulti.svg new file mode 100644 index 0000000..b03b092 --- /dev/null +++ b/images/bothsemimulti.svg @@ -0,0 +1,71 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<svg + xmlns="http://www.w3.org/2000/svg" + xmlns:xlink="http://www.w3.org/1999/xlink" + version="1.1" + viewBox="-10 -10 220 220" + height="120mm" + width="120mm"> + <defs> + <linearGradient id="modele-1" x1="0" x2="0" y1="0" y2="1"> + <stop offset="0%" stop-color="blue" /> + <stop offset="33%" stop-color="blue" /> + <stop offset="34%" stop-color="orange" /> + <stop offset="66%" stop-color="orange" /> + <stop offset="67%" stop-color="green" /> + <stop offset="100%" stop-color="green" /> + </linearGradient> + <linearGradient id="modele-2" x1="0" x2="0" y1="0" y2="1"> + <stop offset="0%" stop-color="blue" /> + <stop offset="33%" stop-color="blue" /> + <stop offset="34%" stop-color="orange" /> + <stop offset="66%" stop-color="orange" /> + <stop offset="67%" stop-color="blue" /> + <stop offset="100%" stop-color="blue" /> + </linearGradient> + <linearGradient id="modele-3" x1="0" x2="0" y1="0" y2="1"> + <stop offset="0%" stop-color="white" /> + <stop offset="33%" stop-color="white" /> + <stop offset="34%" stop-color="red" /> + <stop offset="66%" stop-color="red" /> + <stop offset="67%" stop-color="orange" /> + <stop offset="100%" stop-color="orange" /> + </linearGradient> + </defs> + <g stroke="black" stroke-width="2" fill="white" id="individus"> + <circle cx="25" cy="25" r="10" /> + <circle cx="75" cy="25" r="10" /> + <circle cx="25" cy="75" r="10" /> + <circle cx="75" cy="75" r="10" /> + <line x1="35" x2="65" y1="25" y2="25" /> + <line x1="35" x2="65" y1="75" y2="75" /> + </g> + <use xlink:href="#individus" transform="translate(100 0)" /> + <g stroke="red" stroke-width="2"> + <line x1="146.5" x2="153.5" y1="17" y2="33" /> + <line x1="146.5" x2="153.5" y1="67" y2="83" /> + </g> + <g font-size="8" stroke="black" text-anchor="middle"> + <text x="25" y="30">-1</text> + <text x="75" y="30">-0.8</text> + <text x="25" y="80">+1</text> + <text x="75" y="80">+0.8</text> + <text x="125" y="30">-1</text> + <text x="175" y="30">+1</text> + <text x="125" y="80">-0.8</text> + <text x="175" y="80">+0.8</text> + </g> + <g stroke="black" stroke-width="2"> + <line x1="50" x2="25" y1="125" y2="175" /> + <circle cx="50" cy="125" r="10" fill="url(#modele-1)" /> + <circle cx="25" cy="175" r="10" fill="url(#modele-2)"/> + <circle cx="75" cy="175" r="10" fill="url(#modele-3)"/> + </g> + <g stroke="black" stroke-width="2"> + <line x1="150" x2="125" y1="125" y2="175" /> + <line x1="134" x2="141" y1="142" y2="158" stroke="red" /> + <circle cx="150" cy="125" r="10" fill="url(#modele-1)" /> + <circle cx="125" cy="175" r="10" fill="url(#modele-3)"/> + <circle cx="175" cy="175" r="10" fill="url(#modele-2)"/> + </g> +</svg> diff --git a/images/dirty.svg b/images/dirty.svg new file mode 100644 index 0000000..4e8e76f --- /dev/null +++ b/images/dirty.svg @@ -0,0 +1,77 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<svg + xmlns="http://www.w3.org/2000/svg" + xmlns:xlink="http://www.w3.org/1999/xlink" + version="1.1" + viewBox="-10 -10 220 220" + height="100mm" + width="100mm"> + <g stroke="black" stroke-width="0.7"> + <rect x="0" y="0" width="100" height="200" fill="none" rx="5" /> + <g fill="yellow" fill-opacity="0.2" stroke-width="0.5"> + <g fill="none"> + <rect x="140" y="160" width="10" height="10" /> + </g> + <g fill="blue"> + <rect x="0" y="20" width="100" height="100" /> + <rect x="140" y="175" width="10" height="10" /> + </g> + <rect x="80" y="120" width="20" height="20" /> + <rect x="20" y="140" width="20" height="20" /> + <rect x="60" y="160" width="20" height="20" /> + <rect x="40" y="180" width="20" height="20" /> + <rect x="140" y="190" width="10" height="10" /> + </g> + </g> + <g stroke="black" stroke-width="0.3"> + <line x1="110" x2="110" y1="0" y2="20" /> + <line x1="118" x2="118" y1="20" y2="120" /> + <line x1="110" x2="110" y1="120" y2="200" /> + <g stroke-dasharray="4"> + <line x1="100" x2="116" y1="0" y2="0" /> + <line x1="100" x2="124" y1="20" y2="20" /> + <line x1="100" x2="124" y1="120" y2="120" /> + <line x1="100" x2="116" y1="200" y2="200" /> + </g> + </g> + <g stroke="black" stroke-width="0.1"> + <!-- The grid --> + <line x1="20" x2="20" y1="0" y2="200" /> + <line x1="40" x2="40" y1="0" y2="200" /> + <line x1="60" x2="60" y1="0" y2="200" /> + <line x1="80" x2="80" y1="0" y2="200" /> + <line x1="0" x2="100" y1="20" y2="20" /> + <line x1="0" x2="100" y1="40" y2="40" /> + <line x1="0" x2="100" y1="60" y2="60" /> + <line x1="0" x2="100" y1="80" y2="80" /> + <line x1="0" x2="100" y1="100" y2="100" /> + <line x1="0" x2="100" y1="120" y2="120" /> + <line x1="0" x2="100" y1="140" y2="140" /> + <line x1="0" x2="100" y1="160" y2="160" /> + <line x1="0" x2="100" y1="180" y2="180" /> + </g> + <g stroke="black" stroke-width="0.7"> + <line x1="130" x2="130" y1="150" y2="220" /> + <line x1="130" x2="220" y1="150" y2="150" /> + </g> + <g font-size="6px" font-family="serif"> + <text x="125" y="14"> + variables non pertinentes + </text> + <text x="125" y="70"> + variables communes + </text> + <text x="125" y="135"> + variables différenciantes + </text> + <text x="155" y="168"> + $P = 0$, $Q = 0$ + </text> + <text x="155" y="183"> + $P = 0$, $Q \neq 0$ + </text> + <text x="155" y="198"> + $P \neq 0$, $Q = 0$ + </text> + </g> +</svg> diff --git a/images/featureselectionlizeo.R b/images/featureselectionlizeo.R new file mode 100644 index 0000000..7df6b8c --- /dev/null +++ b/images/featureselectionlizeo.R @@ -0,0 +1,20 @@ +#!/usr/bin/env Rscript +load (sprintf ("%s/data/feature_selection_lizeo.Rdata", Sys.getenv ("ABS_TOP_SRCDIR"))) +Sys.setlocale ("LC_ALL", "fr_FR.UTF-8") +library ("magrittr") +plot <- (feature_selection_lizeo + %>% dplyr::filter (algorithm != "rsms_full") + %>% dplyr::mutate (algorithm = ifelse (algorithm == "rsms", "\\textbf{RSMS}", algorithm)) + %>% dplyr::mutate (algorithm = ifelse (algorithm == "mifs", "MIFS", algorithm)) + %>% dplyr::mutate (algorithm = ifelse (algorithm == "rfs", "RFS", algorithm)) + %>% dplyr::mutate (`% de variables sélectionnées` = n_features / max (n_features)) + %>% dplyr::select (`Algorithme` = algorithm, `% de variables sélectionnées`, `aRMSE` = armse) + %>% dplyr::group_by (Algorithme, `% de variables sélectionnées`) + %>% dplyr::summarize (aRMSE = min (aRMSE)) + %>% ggplot2::ggplot (ggplot2::aes (x = `% de variables sélectionnées`, y = aRMSE, color = Algorithme, linetype = Algorithme)) + + ggplot2::geom_line () + + ggplot2::scale_linetype_manual (values = c ("\\textbf{RSMS}" = "solid", "MIFS" = "dashed", "RFS" = "twodash")) + + ggplot2::scale_color_manual (values = c ("\\textbf{RSMS}" = "#E69F00", "MIFS" = "#56B4E9", "RFS" = "#009E73")) + + ggplot2::scale_x_continuous (trans = 'log10', labels = scales::percent)) +filename <- Sys.getenv ("OUTPUT") +ggplot2::ggsave (filename, plot, device = "svg", width = 6, height = 3) diff --git a/images/featureselectionlizeofull.R b/images/featureselectionlizeofull.R new file mode 100644 index 0000000..c861e28 --- /dev/null +++ b/images/featureselectionlizeofull.R @@ -0,0 +1,19 @@ +#!/usr/bin/env Rscript +load (sprintf ("%s/data/feature_selection_lizeo.Rdata", Sys.getenv ("ABS_TOP_SRCDIR"))) +Sys.setlocale ("LC_ALL", "fr_FR.UTF-8") +library ("magrittr") +plot <- (feature_selection_lizeo + %>% dplyr::filter (algorithm %in% c ("rsms_full", "rsms")) + %>% dplyr::mutate (algorithm = ifelse (algorithm == "rsms_full", "\\textbf{par époques}", algorithm)) + %>% dplyr::mutate (algorithm = ifelse (algorithm == "rsms", "par sous-ensemble", algorithm)) + %>% dplyr::mutate (`Nombre de variables` = n_features / max (n_features)) + %>% dplyr::select (`Variante` = algorithm, `Nombre de variables`, `aRMSE` = armse) + %>% dplyr::group_by (Variante, `Nombre de variables`) + %>% dplyr::summarize (aRMSE = min (aRMSE)) + %>% ggplot2::ggplot (ggplot2::aes (x = `Nombre de variables`, y = aRMSE, color = Variante, linetype = Variante)) + + ggplot2::geom_line () + + ggplot2::scale_linetype_manual (values = c ("\\textbf{par époques}" = "solid", "par sous-ensemble" = "dashed")) + + ggplot2::scale_color_manual (values = c ("\\textbf{par époques}" = "#0072B2", "par sous-ensemble" = "#E69F00")) + + ggplot2::scale_x_continuous (trans = 'log10', labels = scales::percent)) +filename <- Sys.getenv ("OUTPUT") +ggplot2::ggsave (filename, plot, device = "svg", width = 6, height = 3) diff --git a/images/fig-co-training.svg b/images/fig-co-training.svg new file mode 100644 index 0000000..9cffba1 --- /dev/null +++ b/images/fig-co-training.svg @@ -0,0 +1,95 @@ +<?xml version='1.0' encoding='UTF-8' ?> +<svg + xmlns="http://www.w3.org/2000/svg" + xmlns:xlink='http://www.w3.org/1999/xlink' + width="14cm" + viewBox="0 0 640 640"> + <g fill-opacity=".3"> + <rect x="0" y="0" width="640" height="120" fill="#E69F00" /> + <rect x="0" y="240" width="640" height="120" fill="#E69F00" /> + <rect x="0" y="120" width="640" height="120" fill="#56B4E9" /> + <rect x="0" y="360" width="640" height="120" fill="#56B4E9" /> + </g> + <g fill="white"> + <rect x="40" y="20" width="260" height="80" /> + <rect x="40" y="140" width="260" height="80" /> + <rect x="360" y="20" width="260" height="80" /> + <rect x="360" y="140" width="260" height="80" /> + <rect x="40" y="260" width="260" height="80" /> + <rect x="40" y="380" width="260" height="80" /> + <rect x="360" y="260" width="260" height="80" /> + <rect x="360" y="380" width="260" height="80" /> + </g> + <g fill="lightgray"> + <rect x="92" y="20" width="208" height="80" /> + <rect x="92" y="140" width="208" height="80" /> + + <rect x="412" y="20" width="208" height="80" /> + <rect x="412" y="140" width="208" height="80" /> + + <rect x="92" y="260" width="208" height="80" /> + <rect x="92" y="380" width="208" height="80" /> + + <rect x="412" y="260" width="52" height="80" /><rect x="516" y="260" width="104" height="80" /> + <rect x="412" y="380" width="130" height="80" /><rect x="594" y="380" width="26" height="80" /> + </g> + <g fill="#E69F00"> + <rect x="542" y="20" width="52" height="80" /> + <rect x="222" y="380" width="52" height="80" /> + </g> + <g fill="#56B4E9"> + <rect x="464" y="140" width="52" height="80" /> + <rect x="144" y="260" width="52" height="80" /> + </g> + <g stroke="black"> + <rect x="40" y="20" width="260" height="80" fill="none" stroke="black" /> + <rect x="40" y="140" width="260" height="80" fill="none" stroke="black" /> + + <rect x="360" y="20" width="260" height="80" fill="none" stroke="black" /> + <rect x="360" y="140" width="260" height="80" fill="none" stroke="black" /> + + <rect x="40" y="260" width="260" height="80" fill="none" stroke="black" /> + <rect x="40" y="380" width="260" height="80" fill="none" stroke="black" /> + + <rect x="360" y="260" width="260" height="80" fill="none" stroke="black" /> + <rect x="360" y="380" width="260" height="80" fill="none" stroke="black" /> + + <line x1="0" x2="640" y1="240" y2="240" stroke="black" /> + <line x1="320" x2="320" y1="0" y2="480" stroke="black" /> + </g> + <g stroke="black" stroke-dasharray="5,3"> + <line x1="274" x2="274" y1="260" y2="340" /> + <line x1="222" x2="222" y1="260" y2="340" /> + <line x1="196" x2="196" y1="380" y2="460" /> + <line x1="144" x2="144" y1="380" y2="460" /> + </g> + <g stroke="black" fill="white"> + <polygon points="164,400 164,360 144,360 170,320 196,360 178,360 178,400" /> + <polygon points="240,320 240,360 222,360 248,400 274,360 256,360 256,320" /> + </g> + <g text-anchor="end" dominant-baseline="middle"> + <text x="30" y="60">$h_1$</text> + <text x="30" y="180">$h_2$</text> + + <text x="30" y="300">$h_1$</text> + <text x="30" y="420">$h_2$</text> + + <text x="350" y="60">$h_1$</text> + <text x="350" y="180">$h_2$</text> + + <text x="350" y="300">$h_1$</text> + <text x="350" y="420">$h_2$</text> + </g> + <g stroke="black"> + <rect x="7" y="487" width="42" height="42" fill="white" /> + <rect x="7" y="543" width="42" height="42" fill="lightgray" /> + <rect x="327" y="487" width="42" height="42" fill="#E69F00" /> + <rect x="327" y="543" width="42" height="42" fill="#56B4E9" /> + </g> + <g text-anchor="start" dominant-baseline="middle"> + <text x="56" y="508">Labellisé</text> + <text x="56" y="564">Non labellisé</text> + <text x="376" y="508">Valeur prédite par $h_1$</text> + <text x="376" y="564">Valeur prédite par $h_2$</text> + </g> +</svg> diff --git a/images/fig-multi-vues.svg b/images/fig-multi-vues.svg new file mode 100644 index 0000000..41af47a --- /dev/null +++ b/images/fig-multi-vues.svg @@ -0,0 +1,30 @@ +<?xml version='1.0' encoding='UTF-8' ?> +<svg + xmlns="http://www.w3.org/2000/svg" + xmlns:xlink='http://www.w3.org/1999/xlink' + width="10cm" + viewBox="0 0 640 480"> + <g fill-opacity="0.5" stroke="black"> + <rect x="80" y="80" width="160" height="64" fill="#E69F00" /> + <rect x="240" y="80" width="160" height="64" fill="#56B4E9" /> + <rect x="480" y="80" width="80" height="64" fill="#009E73" /> + </g> + <g fill-opacity="0.2" stroke="black"> + <rect x="80" y="144" width="160" height="256" fill="#E69F00" /> + <rect x="240" y="144" width="160" height="256" fill="#56B4E9" /> + <rect x="480" y="144" width="80" height="256" fill="#009E73" /> + </g> + <g text-anchor="middle"> + <text x="160" y="60">$X_1$ (texte)</text> + <text x="320" y="60">$X_2$ (liens)</text> + + <g dominant-baseline="middle"> + <text x="160" y="112">${X_l}_{1}$</text> + <text x="320" y="112">${X_l}_{1}$</text> + <text x="520" y="112">$Y$</text> + + <text x="580" y="112" text-anchor="start">$n$</text> + <text x="60" y="240" text-anchor="end">$N$</text> + </g> + </g> +</svg> diff --git a/images/hireau-s.png b/images/hireau-s.png Binary files differnew file mode 100644 index 0000000..9661c8b --- /dev/null +++ b/images/hireau-s.png diff --git a/images/hireaugramme.png b/images/hireaugramme.png Binary files differnew file mode 100644 index 0000000..6ffb06c --- /dev/null +++ b/images/hireaugramme.png diff --git a/images/insurance_mae.R b/images/insurance_mae.R new file mode 100755 index 0000000..9b0341b --- /dev/null +++ b/images/insurance_mae.R @@ -0,0 +1,5 @@ +#!/usr/bin/env Rscript +source (sprintf ("%s/images/laps3l_graph_code.R", Sys.getenv ("ABS_TOP_SRCDIR"))) +plot <- plot_tuning ("mae", "insurance") +filename <- Sys.getenv ("OUTPUT") +ggplot2::ggsave (filename, plot, device = "svg", width = 6, height = 3) diff --git a/images/insurance_rmse.R b/images/insurance_rmse.R new file mode 100755 index 0000000..9c37ee2 --- /dev/null +++ b/images/insurance_rmse.R @@ -0,0 +1,5 @@ +#!/usr/bin/env Rscript +source (sprintf ("%s/images/laps3l_graph_code.R", Sys.getenv ("ABS_TOP_SRCDIR"))) +plot <- plot_tuning ("rmse", "insurance") +filename <- Sys.getenv ("OUTPUT") +ggplot2::ggsave (filename, plot, device = "svg", width = 6, height = 3) diff --git a/images/l21m2.R b/images/l21m2.R new file mode 100755 index 0000000..8998a49 --- /dev/null +++ b/images/l21m2.R @@ -0,0 +1,20 @@ +#!/usr/bin/env Rscript +`%>%` <- magrittr::`%>%` +xpoints <- seq (-1, 1, length.out = 100) +ypoints <- seq (-1, 1, length.out = 100) +compute_l1 <- function (x, y) abs (x) + abs (y) +compute_l2 <- function (x, y) sqrt (x ^ 2 + y ^ 2) +data <- (tibble::tibble (expand.grid (x = xpoints, y = ypoints)) + %>% dplyr::mutate (`$\\left\\|W\\right\\|_{2, 1}$` = compute_l1 (x, y), + `$\\left\\|W\\right\\|_F$` = compute_l2 (x, y)) + %>% dplyr::mutate (`$\\left\\|W\\right\\|_{2, 1 - 2}$` = + `$\\left\\|W\\right\\|_{2, 1}$` + - `$\\left\\|W\\right\\|_F$`)) + +plotl21 <- (ggplot2::ggplot (data, ggplot2::aes (x = x, y = y, fill = `$\\left\\|W\\right\\|_{2, 1}$`)) + + ggplot2::geom_raster ()) +plotl21m2 <- (ggplot2::ggplot (data, ggplot2::aes (x = x, y = y, fill = `$\\left\\|W\\right\\|_{2, 1 - 2}$`)) + + ggplot2::geom_raster ()) +plot <- gridExtra::arrangeGrob (plotl21, plotl21m2, nrow = 2) +filename <- Sys.getenv ("OUTPUT") +ggplot2::ggsave (filename, plot, device = "svg", width = 5.5, height = 6.5) diff --git a/images/laps3l_graph_code.R b/images/laps3l_graph_code.R new file mode 100644 index 0000000..06b01b0 --- /dev/null +++ b/images/laps3l_graph_code.R @@ -0,0 +1,74 @@ +`%>%` <- magrittr::`%>%` + +load (sprintf ("%s/data/laps3l_tuning.Rdata", Sys.getenv ("ABS_TOP_SRCDIR"))) + +aggregate_tuning_raw <- function (datasets, algorithms) { + data <- tuning + aggregated <- (data + %>% dplyr::filter (dataset %in% datasets, algorithm %in% algorithms) + %>% dplyr::group_by (algorithm, labeled_data, dataset) + %>% dplyr::summarize (armse = mean (rmse), + srmse = sd (rmse), + amae = mean (mae), + smae = sd (mae), + arrse = mean (rrse), + srrse = sd (rrse), + arae = mean (rae), + srae = sd (rae)) + %>% dplyr::ungroup ()) + metrics <- (aggregated + %>% tidyr::pivot_longer (c (armse, srmse, amae, smae, arrse, srrse, arae, srae), + names_to = "metric", + values_to = "value") + %>% dplyr::filter (is.finite (value))) + annotations <- (metrics + %>% dplyr::group_by (labeled_data, dataset, metric) + %>% dplyr::arrange (value) + %>% dplyr::summarize (algorithm = algorithm, is_best = c ( + TRUE, + rep (FALSE, dplyr::n () - 1) + )) + %>% dplyr::ungroup ()) + (metrics + %>% dplyr::inner_join (annotations)) +} + +#' Plot the tuning results +#' @param metric the metric to show: "rmse", "mae", "rrse", "rae" +#' @export +plot_tuning <- function (metric = "rmse", dataset = "wine") { + the_metric <- metric + the_dataset <- dataset + (aggregate_tuning_raw (dataset, c ("laps3l", "sssl", "laprls")) + %>% dplyr::select (algorithm, labeled_data, dataset, metric, value) + %>% dplyr::filter (metric %in% c (sprintf ("a%s", the_metric), + sprintf ("s%s", the_metric)), + dataset == the_dataset) + %>% tidyr::pivot_wider (id_cols = c (algorithm, labeled_data, dataset), + names_from = metric, + values_from = value) + %>% dplyr::rename (mean = sprintf ("a%s", the_metric), + sd = sprintf ("s%s", the_metric)) + %>% dplyr::mutate (low = mean - sd, high = mean + sd) + %>% dplyr::mutate (`Données labellisées` = labeled_data, + Algorithme = + ifelse (algorithm == "sssl", + "SSSL", + ifelse (algorithm == "laprls", + "LapRLS", + "\\textbf{LapS3L}")), + Value = mean, + low = low, + high = high) + %>% ggplot2::ggplot (ggplot2::aes (x = `Données labellisées`, + y = Value, + ymin = low, + ymax = high, + linetype = Algorithme, + color = Algorithme, + fill = Algorithme)) + + ggplot2::geom_line () + + ggplot2::geom_ribbon (alpha = 0.2, size = 0) + + ggplot2::ylab (metric) + + ggplot2::ggtitle (sprintf ("jeu de données %s, métrique %s", dataset, metric))) +} diff --git a/images/lasso.svg b/images/lasso.svg new file mode 100644 index 0000000..35ae633 --- /dev/null +++ b/images/lasso.svg @@ -0,0 +1,55 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<svg + xmlns="http://www.w3.org/2000/svg" + xmlns:xlink="http://www.w3.org/1999/xlink" + version="1.1" + viewBox="-10 -10 240 170" + height="75mm" + width="100mm"> + <defs> + <clipPath id="figure-gauche-clip"> + <rect x="00" y="00" width="100" height="100" /> + </clipPath> + <clipPath id="figure-droite-clip"> + <rect x="120" y="0" width="100" height="100" /> + </clipPath> + <!-- Une figure, c'est un fond gris, deux axes en blanc dessus, et + la figure (qui est en fait un croisement de deux diagonales + avec une largeur très élevée) --> + <g id="figure-base"> + <rect x="0" y="0" width="100" height="100" fill="#D3D3D3" /> + <line x1="50" x2="50" y1="0" y2="100" stroke="white" stroke-width="0.5" /> + <line x1="0" x2="100" y1="50" y2="50" stroke="white" stroke-width="0.5"/> + <line class="domaine" + x1="0" x2="100" y1="0" y2="100" + stroke="blue" opacity=".2" /> + <line class="domaine" + x1="0" x2="100" y1="100" y2="0" + stroke="blue" opacity=".2" /> + </g> + <g id="figure-decalee"> + <use xlink:href="#figure-base" transform="translate (120 0)" /> + </g> + </defs> + <use clip-path="url(#figure-gauche-clip)" + xlink:href="#figure-base" + id="gauche" + stroke-width="20"/> + <use clip-path="url(#figure-droite-clip)" + xlink:href="#figure-decalee" + id="droite" + stroke-width="50"/> + <text x="50" y="115" text-anchor="middle" font-size="10px">$\alpha$ grand</text> + <text x="170" y="115" text-anchor="middle" font-size="10px">$\alpha$ petit</text> + + <rect x="0" y="125" width="20" height="15" fill="#D3D3D3" /> + <text x="30" y="135" font-size="10px"> + le modèle a une composante nulle + </text> + + <rect x="0" y="145" width="20" height="15" fill="#D3D3D3" /> + <rect x="0" y="145" width="20" height="15" fill="blue" opacity=".2" /> + <text x="30" y="155" font-size="10px"> + le modèle est dense + </text> +</svg> diff --git a/images/lizeo-donnees.png b/images/lizeo-donnees.png Binary files differnew file mode 100644 index 0000000..c520299 --- /dev/null +++ b/images/lizeo-donnees.png diff --git a/images/lizeoclassif.svg b/images/lizeoclassif.svg new file mode 100644 index 0000000..94ef436 --- /dev/null +++ b/images/lizeoclassif.svg @@ -0,0 +1,55 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<svg + xmlns="http://www.w3.org/2000/svg" + xmlns:xlink="http://www.w3.org/1999/xlink" + version="1.1" + viewBox="0 0 200 200" + width="80mm" + height="80mm"> + <text x="70" y="12" text-anchor="middle" font-size="8px"> + Variables textuelles + </text> + <g transform="rotate(-90) translate(-100, 12)"> + <text text-anchor="middle" font-size="8px"> + documents + </text> + </g> + <g transform="rotate (-90) translate(-15, 145)"> + <text text-anchor="left" font-size="4px"> + Prix + </text> + </g> + <g transform="rotate (-90) translate(-15, 155)"> + <text text-anchor="left" font-size="4px"> + Bruit + </text> + </g> + <text x="172" y="15" text-anchor="middle" font-size="6px"> + ... + </text> + <text x="190" y="195" text-anchor="end" font-size="6px"> + \textit{qualifiers} + </text> + <text x="70" y="130" text-anchor="middle" font-size="20px"> + ... + </text> + <text x="175" y="130" text-anchor="middle" font-size="20px"> + $\{1, 0\}$ + </text> + + <rect x="20" y="20" width="100" height="160" rx="5" stroke="black" stroke-width=".5" fill="none" /> + <rect x="140" y="20" width="50" height="160" rx="5" stroke="black" stroke-width=".5" fill="none" /> + + <rect x="150" y="20" width="10" height="20" fill="gray" /> + <rect x="140" y="40" width="10" height="20" fill="gray" /> + <rect x="150" y="60" width="10" height="20" fill="gray" /> + + <line x1="20" x2="120" y1="40" y2="40" stroke="black" stroke-width=".1" /> + <line x1="20" x2="120" y1="60" y2="60" stroke="black" stroke-width=".1" /> + <line x1="20" x2="120" y1="80" y2="80" stroke="black" stroke-width=".1" /> + <line x1="140" x2="190" y1="40" y2="40" stroke="black" stroke-width=".1" /> + <line x1="140" x2="190" y1="60" y2="60" stroke="black" stroke-width=".1" /> + <line x1="140" x2="190" y1="80" y2="80" stroke="black" stroke-width=".1" /> + <line x1="150" x2="150" y1="20" y2="180" stroke="black" stroke-width=".1" /> + <line x1="160" x2="160" y1="20" y2="180" stroke="black" stroke-width=".1" /> +</svg> diff --git a/images/lizeoreg.svg b/images/lizeoreg.svg new file mode 100644 index 0000000..4561c1d --- /dev/null +++ b/images/lizeoreg.svg @@ -0,0 +1,55 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<svg + xmlns="http://www.w3.org/2000/svg" + xmlns:xlink="http://www.w3.org/1999/xlink" + version="1.1" + viewBox="0 0 200 200" + height="80mm" + width="80mm"> + <text x="70" y="12" text-anchor="middle" font-size="8px"> + Variables textuelles + </text> + <g transform="rotate(-90) translate(-100, 12)"> + <text text-anchor="middle" font-size="8px"> + documents + </text> + </g> + <g transform="rotate (-90) translate(-15, 145)"> + <text text-anchor="left" font-size="4px"> + Prix + </text> + </g> + <g transform="rotate (-90) translate(-15, 155)"> + <text text-anchor="left" font-size="4px"> + Bruit + </text> + </g> + <text x="172" y="15" text-anchor="middle" font-size="6px"> + ... + </text> + <text x="190" y="195" text-anchor="end" font-size="6px"> + \textit{qualifiers} + </text> + <text x="70" y="130" text-anchor="middle" font-size="20px"> + ... + </text> + <text x="175" y="130" text-anchor="middle" font-size="20px"> + $\mathbb{R}$ + </text> + + <rect x="150" y="20" width="10" height="20" fill="orange" /> + <rect x="140" y="40" width="10" height="20" fill="blue" opacity=".4" /> + <rect x="150" y="60" width="10" height="20" fill="orange" opacity=".3" /> + + <rect x="20" y="20" width="100" height="160" rx="5" stroke="black" stroke-width=".5" fill="none" /> + <rect x="140" y="20" width="50" height="160" rx="5" stroke="black" stroke-width=".5" fill="none" /> + + <line x1="20" x2="120" y1="40" y2="40" stroke="black" stroke-width=".1" /> + <line x1="20" x2="120" y1="60" y2="60" stroke="black" stroke-width=".1" /> + <line x1="20" x2="120" y1="80" y2="80" stroke="black" stroke-width=".1" /> + <line x1="140" x2="190" y1="40" y2="40" stroke="black" stroke-width=".1" /> + <line x1="140" x2="190" y1="60" y2="60" stroke="black" stroke-width=".1" /> + <line x1="140" x2="190" y1="80" y2="80" stroke="black" stroke-width=".1" /> + <line x1="150" x2="150" y1="20" y2="180" stroke="black" stroke-width=".1" /> + <line x1="160" x2="160" y1="20" y2="180" stroke="black" stroke-width=".1" /> +</svg> diff --git a/images/logo.png b/images/logo.png Binary files differnew file mode 100644 index 0000000..7da55d2 --- /dev/null +++ b/images/logo.png diff --git a/images/lsmr_global_tuning.R b/images/lsmr_global_tuning.R new file mode 100644 index 0000000..3753e09 --- /dev/null +++ b/images/lsmr_global_tuning.R @@ -0,0 +1,94 @@ +load (sprintf ("%s/data/lsmr_global_tuning.Rdata", Sys.getenv ("ABS_TOP_SRCDIR"))) + +#' Compute the Friedman + Nemenyi analysis with the tsutils package. +#' +#' @return the tsutils analysis. +#' @export +cd_analysis <- function () { + `%>%` <- magrittr::`%>%` + data <- (global_tuning_data + %>% dplyr::select (`LSMR local` = lsmr_local, dplyr::everything ()) + %>% dplyr::select (-dataset)) + colnames (data) <- toupper (colnames (data)) + colnames (data) <- gsub ("LOCAL", "local", colnames (data)) + tsutils::nemenyi (as.matrix (data), plottype = "vmcb") +} + +## Expects that higher is better. Returns -1 if the first is better, +## +1 if the second is better, and 0 otherwise. +paired_test_aux <- function (algo1, algo2) { + diff <- algo2 - algo1 + magnitude <- abs (diff) + sorted_magnitude <- sort (magnitude) + get_rank <- function (diff) { + m <- abs (diff) + ok <- which (sorted_magnitude == m) + mean (ok) + } + ranks <- sapply (diff, get_rank) + positives <- which (diff > 0) + negatives <- which (diff < 0) + ties <- which (diff == 0) + Rplus <- sum (ranks[positives]) + sum (ranks[ties]) / 2 + Rminus <- sum (ranks[negatives]) + sum (ranks[ties]) / 2 + ret <- 0 + if (Rplus < Rminus) { + ret <- -1 + } else { + ret <- +1 + } + T <- min (Rplus, Rminus) + N <- length (diff) + znum <- (T - (1 / 4) * N * (N + 1)) + ## ------------------------------ + zdenom <- sqrt ((1 / 24) * N * (N + 1) * (2 * N + 1)) + z <- znum / zdenom + alpha <- 0.1 + crit <- qnorm (1 - alpha / 2) + if (z >= -crit) { + ret <- 0 + } + ret +} + +paired_test <- function (algo1, algo2) { + data <- global_tuning_data + algo1 <- data[, algo1 + 1][[1]] + algo2 <- data[, algo2 + 1][[1]] + paired_test_aux (-algo1, -algo2) +} + +#' Compute the win / lose / tie matrix for all pairs of algorithms. +#' @return the matrix with row and column names set to the names of +#' the algorithms. +#' @export +win_lose_tie_paired_tests <- function () { + data <- global_tuning_data + M <- matrix (0, ncol (data) - 1, ncol (data) - 1) + colnames (M) <- toupper (gsub ("_", "\n", colnames (data)[2:ncol (data)], fixed = TRUE)) + colnames (M) <- gsub ("LOCAL", "local", colnames (M)) + row.names (M) <- colnames (M) + colnames (M) <- gsub ("LSMR\nlocal", "LSMR (l)", colnames (M), fixed = TRUE) + for (i in seq_len (ncol (data) - 1)) { + for (j in seq_len (ncol (data) - 1)) { + M[i, j] <- paired_test (i, j) + } + } + M +} + +#' Print the plot of the win / lose / tie matrix +#' @return Org-mode code +#' @export +print_win_lose_tie_plot <- function () { + M <- win_lose_tie_paired_tests () + data <- reshape2::melt (M, na.rm = TRUE) + (ggplot2::ggplot (data = data, + ggplot2::aes (Var2, Var1, fill = value)) + + ggplot2::geom_tile (color = "white") + + ggplot2::scale_fill_gradient2 (low = "blue", high = "red", mid = "#FFFFFF00", + midpoint = 0, limit = c (-1, 1), name = "significant test") + + ggplot2::theme (legend.position = "none") + + ggplot2::theme (axis.title = ggplot2::element_blank ()) + + ggplot2::theme (axis.text.x = ggplot2::element_text (angle=45, hjust=1))) +} diff --git a/images/lsmr_local_oes97.R b/images/lsmr_local_oes97.R new file mode 100644 index 0000000..aba51eb --- /dev/null +++ b/images/lsmr_local_oes97.R @@ -0,0 +1,5 @@ +#!/usr/bin/env Rscript +source (sprintf ("%s/images/lsmr_local_tuning.R", Sys.getenv ("ABS_TOP_SRCDIR"))) +plot <- print_local_graph ("oes97") +filename <- Sys.getenv ("OUTPUT") +ggplot2::ggsave (filename, plot, device = "svg", width = 6, height = 4) diff --git a/images/lsmr_local_osales.R b/images/lsmr_local_osales.R new file mode 100644 index 0000000..f2d61c0 --- /dev/null +++ b/images/lsmr_local_osales.R @@ -0,0 +1,5 @@ +#!/usr/bin/env Rscript +source (sprintf ("%s/images/lsmr_local_tuning.R", Sys.getenv ("ABS_TOP_SRCDIR"))) +plot <- print_local_graph ("osales") +filename <- Sys.getenv ("OUTPUT") +ggplot2::ggsave (filename, plot, device = "svg", width = 6, height = 4) diff --git a/images/lsmr_local_scpf.R b/images/lsmr_local_scpf.R new file mode 100644 index 0000000..a276c83 --- /dev/null +++ b/images/lsmr_local_scpf.R @@ -0,0 +1,5 @@ +#!/usr/bin/env Rscript +source (sprintf ("%s/images/lsmr_local_tuning.R", Sys.getenv ("ABS_TOP_SRCDIR"))) +plot <- print_local_graph ("scpf") +filename <- Sys.getenv ("OUTPUT") +ggplot2::ggsave (filename, plot, device = "svg", width = 6, height = 4) diff --git a/images/lsmr_local_sf2.R b/images/lsmr_local_sf2.R new file mode 100644 index 0000000..6406c72 --- /dev/null +++ b/images/lsmr_local_sf2.R @@ -0,0 +1,5 @@ +#!/usr/bin/env Rscript +source (sprintf ("%s/images/lsmr_local_tuning.R", Sys.getenv ("ABS_TOP_SRCDIR"))) +plot <- print_local_graph ("sf2") +filename <- Sys.getenv ("OUTPUT") +ggplot2::ggsave (filename, plot, device = "svg", width = 6, height = 4) diff --git a/images/lsmr_local_tuning.R b/images/lsmr_local_tuning.R new file mode 100644 index 0000000..8ad743a --- /dev/null +++ b/images/lsmr_local_tuning.R @@ -0,0 +1,329 @@ +load (sprintf ("%s/data/lsmr_local_tuning.Rdata", Sys.getenv ("ABS_TOP_SRCDIR"))) + +#' Construct a linear kernel +#' +#' @return a linear kernel +#' @export +linear_kernel <- function () { + ret <- list () + class (ret) <- "linear_kernel" + ret +} + +#' Construct a cosine kernel +#' +#' @return a cosine kernel +#' @export +cosine_kernel <- function () { + ret <- list () + class (ret) <- "cosine_kernel" + ret +} + +#' Construct a RBF kernel +#' +#' @param bandwidth the sigma parameter for the RBF... +#' @param gamma ... or alternatively the gamma parameter +#' @return an RBF kernel +#' @export +rbf_kernel <- function (bandwidth = NULL, gamma = NULL) { + stopifnot (!is.null (bandwidth) || !is.null (gamma)) + if (is.null (gamma)) { + gamma <- 1 / (2 * bandwidth ^ 2) + } + ret <- list (gamma = gamma) + class (ret) <- "rbf_kernel" + ret +} + +#' Construct a Laplacian matrix with binary relations +#' +#' @param kernel the kernel to compute base similarities +#' @param quantile used to compute the threshold. +#' @return a Laplacian matrix generator +#' @export +quantile_laplacian <- function (kernel = linear_kernel (), quantile = 0.95) { + ret <- list (kernel = kernel, q = quantile) + class (ret) <- "quantile_laplacian" + ret +} + +#' Apply a kernel over two data matrices +#' +#' @param x the kernel to apply +#' @param U the first data matrix +#' @param V the second data matrix (may be missing) +#' @return the kernel matrix +#' @export +cache <- function (x, U, V) { + UseMethod ("cache", x) +} + +#' @method cache linear_kernel +#' @export +cache.linear_kernel <- function (x, U, V = NULL) { + if (is.null (V)) { + V <- U + } + tcrossprod (U, V) +} + +#' @method cache cosine_kernel +#' @export +cache.cosine_kernel <- function (x, U, V = NULL) { + if (is.null (V)) { + V <- U + } + num <- tcrossprod (U, V) + nu <- sqrt (rowSums (U^2)) + nv <- sqrt (rowSums (V^2)) + denom <- tcrossprod (nu, nv) + ret <- num / denom + ret[denom == 0] <- 1 + ret +} + +pdist <- function (U, V = NULL) { + if (is.null (V)) { + V <- U + } + rsu <- as.matrix (rowSums (U^2), nrow (U), 1) + rsv <- as.matrix (rowSums (V^2), nrow (V), 1) + Du <- rsu[, array (1, nrow (V)), drop = FALSE] + Dv <- t (rsv[, array (1, nrow (U)), drop = FALSE]) + D <- Du + Dv - 2 * tcrossprod (U, V) + D[D < 0] <- 0 + D +} + +#' @method cache rbf_kernel +#' @export +cache.rbf_kernel <- function (x, U, V = NULL) { + gamma <- x$gamma + exp (- gamma * pdist (U, V)) +} + +#' @method cache quantile_laplacian +#' @export +cache.quantile_laplacian <- function (x, U, V = NULL) { + if (!is.null (V)) { + stop ("Cannot apply the Laplacian matrix on two different data matrices") + } + K <- cache (x$kernel, U) + q <- stats::quantile (K[upper.tri (K)], x$q) + M <- matrix (0, nrow (K), ncol (K)) + M[K < q] <- 0 + M[K >= q] <- 1 + D <- rowSums (M) + diag (D, nrow (K), ncol (K)) - M +} + +#' Construct a RBF kernel fit for a validation dataset +#' +#' @param x a validation data matrix +#' @param y the validation label matrix +#' @return a RBF kernel +#' @export +tune_rbf_kernel <- function (x, y) { + B <- cache (cosine_kernel (), t (t (y))) + B[B < 0] <- 0 + b <- t (t (c (B))) + D <- pdist (x) + candidates <- c (1e-4, 2e-4, 5e-4, + 1e-3, 2e-3, 5e-3, + 1e-2, 2e-2, 5e-2, + 1e-1, 2e-1, 5e-1, + 1e+0, 2e+0, 5e+0, + 1e+1, 2e+1, 5e+1, + 1e+2, 2e+2, 5e+2, + 1e+3, 2e+3, 5e+3, + 1e+4, 2e+4, 5e+4) + alignment <- sapply (candidates, function (gamma) { + K <- exp (-gamma * D) + k <- t (t (c (K))) + alignment <- cache.cosine_kernel (NULL, t (b), t (k)) + alignment[1, 1] + }) + rbf_kernel (gamma = candidates[which.max (alignment)]) +} + + +#' Load the local tuning results. +#' +#' @return A table with the following columns: 'dataset', 'kernel', +#' 'bandwidth', 's', 'semi', 'multi', 'armse_sssl', 'armse_semi', +#' 'armse_multi', 'armse_both'. +#' @export +get_local_tuning_data <- function () { + local_tuning +} + +#' Print the results for the local tuning. +#' +#' @return the data. +#' @export +print_tbl_comparison_local <- function () { + data <- get_local_tuning_data () + `%>%` <- magrittr::`%>%` + number <- function (x) { + sapply (x, function (x) { + if (x <= 1) { + sprintf ("*%.3f*", x) + } else { + sprintf ("%.3f", x) + } + }) + } + summaries <- (data + %>% dplyr::group_by (dataset) + %>% dplyr::summarize (median_sssl = median (armse_sssl), + mean = mean (armse_both), + median = median (armse_both), + q1 = quantile (armse_both, .25), + q3 = quantile (armse_both, .75), + min = min (armse_both), + max = max (armse_both)) + %>% dplyr::mutate (relative_mean = mean / median_sssl, + relative_median = median / median_sssl, + relative_q1 = q1 / median_sssl, + relative_q3 = q3 / median_sssl, + relative_min = min / median_sssl, + relative_max = max / median_sssl) + %>% dplyr::mutate (`*Données*` = dataset, + `Moyenne` = number (relative_mean), + `Médiane` = number (relative_median), + `Q1` = number (relative_q1), + `Q3` = number (relative_q3), + `Meilleur` = number (relative_min), + `Pire` = number (relative_max)) + %>% dplyr::select (`*Données*`, `Moyenne`, `Q1`, `Q3`, `Meilleur`, `Pire`) + %>% dplyr::arrange (`Meilleur`)) + summaries +} + +rescale_log <- function (value, min, max) { + log_min <- log (min) + log_max <- log (max) + log_value <- log_min + value * (log_max - log_min) + exp (log_value) +} + +laps3l_decode_hyper <- function (max_s) { + min_bandwidth <- 0.1 + max_bandwidth <- 300 + min_semi <- 1e-08 + max_semi <- 1 + min_multi <- 1e-04 + max_multi <- 10000 + min_s <- 1 + function (row) { + kernel <- NULL + row$kernel <- as.character (row$kernel) + if (row$kernel == "cosine") { + kernel <- cosine_kernel () + } + else if (row$kernel == "linear") { + kernel <- linear_kernel () + } + else { + stopifnot (row$kernel == "rbf") + bw <- rescale_log (row$bandwidth, min_bandwidth, max_bandwidth) + kernel <- rbf_kernel (bw) + } + list (kernel = kernel, + semi = rescale_log (row$semi, min_semi, max_semi), + multi = rescale_log (row$multi, min_multi, max_multi), + s = round (rescale_log (row$s, min_s, max_s))) + } +} + +#' Print a local graph +#' +#' @param graph which graph to plot +#' @return a ggplot object. +#' @export +print_local_graph <- function (graph = "atp1d") { + max_s <- NA + if (graph == "atp1d") { + max_s <- 262 + } else if (graph == "atp7d") { + max_s <- 234 + } else if (graph == "edm") { + max_s <- 121 + } else if (graph == "enb") { + max_s <- 601 + } else if (graph == "jura") { + max_s <- 281 + } else if (graph == "oes10") { + max_s <- 314 + } else if (graph == "oes97") { + max_s <- 257 + } else if (graph == "osales") { + max_s <- 495 + } else if (graph == "sarcossub") { + max_s <- 779 + } else if (graph == "scpf") { + max_s <- 889 + } else if (graph == "sf1") { + max_s <- 250 + } else if (graph == "sf2") { + max_s <- 832 + } else if (graph == "wq") { + max_s <- 827 + } else { + stop ("Unknown dataset") + } + d <- laps3l_decode_hyper (max_s) + decode_row <- function (data, i) { + row <- data[i,] + row$kernel <- "linear" + row$s <- 0 + items <- d (row) + data$semi[i] <- items$semi + data$multi[i] <- items$multi + data[i,] + } + decode <- function (data) { + do.call (rbind, lapply (seq_len (nrow (data)), function (i) decode_row (data, i))) + } + smooth <- function (data) { + X <- as.matrix (cbind (data$semi, data$multi)) + y <- t (t (data$relative_armse)) + D <- as.matrix (dist (X, diag = T, upper = T)) + M <- 0 * D + M[D < 0.1] <- 1 + sum <- rowSums (M) + M <- diag (1 / sum, nrow (X), nrow (X)) %*% M + data$relative_armse <- M %*% y + data + } + data <- get_local_tuning_data () + `%>%` <- magrittr::`%>%` + armse_sssl_median <- median ((data + %>% dplyr::filter (dataset == graph) + %>% dplyr::select (armse_sssl))$armse_sssl, na.rm = TRUE) + relative_data <- (data + %>% dplyr::filter (dataset == graph) + %>% dplyr::mutate (relative_armse = armse_both / armse_sssl_median) + %>% dplyr::select (semi, multi, relative_armse)) + averaged <- smooth (relative_data) + intp <- with (averaged, + akima::interp (x = semi, + y = multi, + z = relative_armse, + duplicate = "mean")) + values <- as.data.frame (as.matrix (intp$z)) + colnames (values) <- intp$y + intp <- (tidyr::gather (cbind (values, semi = intp$x), + multi, armse, seq_len (ncol (intp$z)), + na.rm = TRUE) + %>% dplyr::mutate (multi = as.numeric (multi))) + interpolated <- (intp %>% decode ()) + (ggplot2::ggplot (interpolated, ggplot2::aes (x = semi, y = multi, fill = armse)) + + ggplot2::geom_tile () + + ggplot2::scale_fill_gradient2 (midpoint = 1, name = "aRMSE\nrelative") + + ggplot2::xlab ("Régulariseur semi-supervisé $\\alpha$") + + ggplot2::ylab ("Régulariseur multi-label $\\beta$") + + ggplot2::scale_x_log10 () + + ggplot2::scale_y_log10 ()) +} diff --git a/images/lsmrrsmsapprentissage.svg b/images/lsmrrsmsapprentissage.svg new file mode 100644 index 0000000..766a2d9 --- /dev/null +++ b/images/lsmrrsmsapprentissage.svg @@ -0,0 +1,324 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<svg + xmlns="http://www.w3.org/2000/svg" + xmlns:xlink="http://www.w3.org/1999/xlink" + version="1.1" + viewBox="0 0 210 297" + height="217.8mm" + width="154mm"> + <defs> + <g id="laplacian-matrix-base"> + <g fill="Teal"> + <rect x="-10" y="-10" width="4" height="4" /> + <rect x="-6" y="-6" width="4" height="4" /> + <rect x="-2" y="-2" width="4" height="4" /> + <rect x="2" y="2" width="4" height="4" /> + <rect x="6" y="6" width="4" height="4" /> + </g> + <g stroke-width=".2" stroke="Teal"> + <line x1="-6" x2="-6" y1="-10" y2="10" /> + <line x1="-2" x2="-2" y1="-10" y2="10" /> + <line x1="2" x2="2" y1="-10" y2="10" /> + <line x1="6" x2="6" y1="-10" y2="10" /> + <line y1="-6" y2="-6" x1="-10" x2="10" /> + <line y1="-2" y2="-2" x1="-10" x2="10" /> + <line y1="2" y2="2" x1="-10" x2="10" /> + <line y1="6" y2="6" x1="-10" x2="10" /> + </g> + <rect x="-10" y="-10" width="20" height="20" stroke="Teal" stroke-width=".2" fill="none" /> + </g> + <g id="laplacian-matrix-1"> + <rect x="-10" y="-10" width="20" height="20" stroke="none" fill="white" /> + <g fill="PaleTurquoise"> + <rect x="-6" y="-10" width="4" height="4" /> + <rect x="2" y="-10" width="4" height="4" /> + <rect x="-10" y="-6" width="4" height="4" /> + <rect x="6" y="-6" width="4" height="4" /> + <rect x="2" y="-2" width="4" height="4" /> + <rect x="6" y="-2" width="4" height="4" /> + <rect x="-10" y="2" width="4" height="4" /> + <rect x="-2" y="2" width="4" height="4" /> + <rect x="-6" y="6" width="4" height="4" /> + <rect x="-2" y="6" width="4" height="4" /> + </g> + <use xlink:href="#laplacian-matrix-base" /> + </g> + <g id="laplacian-matrix-2"> + <rect x="-10" y="-10" width="20" height="20" stroke="none" fill="white" /> + <g fill="PaleTurquoise"> + <rect x="-2" y="-10" width="4" height="4" /> + <rect x="2" y="-6" width="4" height="4" /> + <rect x="-10" y="-2" width="4" height="4" /> + <rect x="-6" y="2" width="4" height="4" /> + <rect x="6" y="2" width="4" height="4" /> + <rect x="2" y="6" width="4" height="4" /> + </g> + <use xlink:href="#laplacian-matrix-base" /> + </g> + </defs> + <g id="page-rsms"> + <rect x="10" y="10" width="70" height="140" + fill="white" /> + <rect x="10" y="15" width="70" height="15" + fill="WhiteSmoke" /> + <line x1="10" y1="15" x2="80" y2="15" + stroke="SlateGray" stroke-width="1" /> + <text fill="DimGray" x="45" y="27" font-size="10" text-anchor="middle"> + 1) RSMS + </text> + <line x1="10" y1="30" x2="80" y2="30" + stroke="SlateGray" stroke-width=".2" /> + <rect x="10" y="10" width="70" height="140" + stroke="SlateGray" stroke-width="0.2" fill="none" /> + <g stroke="black" stroke-width=".2"> + <rect fill="WhiteSmoke" x="20" y="40" width="30" height="60" /> + <line x1="40" x2="40" y1="40" y2="100" /> + <line x1="20" x2="50" y1="60" y2="60" /> + <line x1="20" x2="50" y1="80" y2="80" /> + </g> + <g font-size="5" text-anchor="middle" fill="DimGray"> + <text x="30" y="39"> $X$ </text> + <text x="45" y="39"> $Y$ </text> + <text x="65" y="39"> $L$ </text> + </g> + <use xlink:href="#laplacian-matrix-2" transform="translate (65 50) scale(0.9)" /> + <use xlink:href="#laplacian-matrix-1" transform="translate (65 70) scale(0.9)" /> + <use xlink:href="#laplacian-matrix-2" transform="translate (65 90) scale(0.9)" /> + <g font-size="5" fill="DimGray"> + <text x="20" y="112"> + À chaque époque : + </text> + <text x="25" y="118"> + 1 itération pour + </text> + <text x="25" y="124"> + chaque minibatch + </text> + </g> + <line x1="22" x2="22" y1="114" y2="124" stroke="DimGray" stroke-width=".2" /> + <rect x="15" y="130" width="60" height="15" fill="LavenderBlush" /> + <line x1="15" x2="75" y1="130" y2="130" stroke="DimGray" stroke-width=".2" /> + <text x="70" y="140" font-size="5" fill="DimGray" text-anchor="end"> + Variables + </text> + <rect fill="none" stroke="black" stroke-width=".2" x="15" y="105" width="60" height="40" /> + <polygon points="20,135 28,135 28,131 35,137.5 28,144 28,140 20,140" fill="white" stroke="maroon" stroke-width=".2" /> + </g> + + <g id="page-bootstrap"> + <g stroke-width="0.2"> + <rect x="120" y="40" width="80" height="140" fill="DimGray" stroke="black" /> + <rect x="110" y="30" width="80" height="140" fill="white" stroke="SlateGray"/> + <rect x="100" y="20" width="80" height="140" fill="DimGray" stroke="black" /> + <rect x="90" y="10" width="80" height="140" fill="white" stroke="SlateGray"/> + </g> + <rect x="90" y="10" width="80" height="140" + fill="white" /> + <rect x="90" y="15" width="80" height="15" + fill="WhiteSmoke" /> + <line x1="90" y1="15" x2="170" y2="15" + stroke="SlateGray" stroke-width="1" /> + <text fill="DimGray" x="130" y="27" font-size="10" text-anchor="middle"> + 2) LSMR + </text> + <line x1="90" y1="30" x2="170" y2="30" + stroke="SlateGray" stroke-width=".2" /> + <g font-size="7" text-anchor="end"> + <text x="175" y="158" fill="WhiteSmoke"> + aRMSE trop élevée + </text> + <text x="185" y="168" fill="DimGray"> + Sélectionné + </text> + </g> + <rect x="90" y="130" width="80" height="20" fill="LavenderBlush" /> + <rect x="95" y="40" width="40" height="80" fill="WhiteSmoke" /> + + <use xlink:href="#laplacian-matrix-1" transform="translate (155 50) scale(0.9)" /> + <g font-size="5" text-anchor="middle" fill="DimGray"> + <text x="112.5" y="39"> $X$ </text> + <text x="130" y="39"> $Y$ </text> + <text x="155" y="39"> $L$ </text> + </g> + <text fill="DimGray" x="97" y="52" font-size="5"> + Apprentissage + </text> + <text fill="DimGray" x="97" y="72" font-size="5"> + Validation + </text> + <text fill="DimGray" x="97" y="92" font-size="5"> + Hors du sac + </text> + <text fill="DimGray" x="97" y="112" font-size="5"> + (Out Of Bag) + </text> + <g stroke="black" stroke-width=".2"> + <rect x="95" y="40" width="40" height="80" fill="none" /> + <line x1="95" y1="60" x2="135" y2="60" /> + <line x1="95" y1="80" x2="135" y2="80" /> + <line x1="125" y1="40" x2="125" y2="120" /> + </g> + <line x1="90" x2="170" y1="130" y2="130" stroke="SlateGray" stroke-width=".2" /> + <line x1="140" x2="140" y1="130" y2="150" stroke="SlateGray" stroke-width=".2" /> + <line x1="90" x2="140" y1="140" y2="140" stroke="SlateGray" stroke-width=".2" /> + <rect x="90" y="10" width="80" height="140" + stroke="SlateGray" stroke-width="0.2" fill="none" /> + + <rect x="140" y="70" width="30" height="50" fill="beige" /> + <polygon fill="ivory" points="170,70 200,100 200,150 170,120" /> + <polygon stroke="DarkKhaki" stroke-width="0.2" fill="none" + points="140,70 170,70 200,100 200,150 170,120 140,120" /> + <g font-size="5" fill="DimGray"> + <text x="145" y="80"> + Faire + </text> + <text x="145" y="88"> + varier : + </text> + <g text-anchor="end"> + <text x="170" y="96"> + - échan + </text> + <text x="170" y="104"> + - hyper + </text> + </g> + <text transform="translate (170, 96) rotate (45)"> + tillons + </text> + <text transform="translate(170, 104) rotate (45)"> + paramètres + </text> + </g> + <line x1="170" y1="70" x2="170" y2="120" stroke="white" stroke-width=".2" /> + <g font-size="5" text-anchor="middle"> + <text x="115" y="138" fill="DimGray"> + aRMSE + </text> + <text x="115" y="148" fill="DimGray"> + OOB + </text> + <text x="155" y="143" fill="DimGray"> + Modèle + </text> + </g> + <polyline points="70,138 85,138 85,37 100,37 98,35 100,37 98,39 100,37" + stroke-width="1" + stroke="CornflowerBlue" + fill="none"/> + </g> + + <g id="page-aggregation"> + <polygon points="10,160 80,160 110,190 110,290 10,290" + fill="white" /> + <polygon points="10,165 85,165 100,180 10,180" + fill="WhiteSmoke" /> + <line x1="10" y1="165" x2="85" y2="165" + stroke="SlateGray" stroke-width="1" /> + <text fill="DimGray" x="50" y="177" font-size="10" text-anchor="middle"> + 3) Stacking + </text> + <line x1="10" y1="180" x2="100" y2="180" + stroke="SlateGray" stroke-width=".2" /> + + <text fill="DimGray" x="20" y="188" font-size="5"> + Par qualifier (indiv. pertinents) : + </text> + + <rect x="15" y="190" width="30" height="40" + stroke="DarkOliveGreen" stroke-width=".2" fill="none" /> + <g> + <rect x="22" y="197" width="5" height="23" fill="LavenderBlush" stroke="maroon" stroke-width=".2" /> + <rect x="20" y="195" width="5" height="5" fill="white" stroke="SlateGray" stroke-width=".2" /> + <rect x="20" y="200" width="5" height="18" fill="LavenderBlush" stroke="maroon" stroke-width=".2" /> + <g font-size="5" text-anchor="middle" fill="DimGray"> + <text x="22.5" y="200">?</text> + <text x="22.5" y="206">O</text> + <text x="22.5" y="212">O</text> + <text x="22.5" y="218">B</text> + </g> + <rect x="35.5" y="196" width="5" height="23" fill="WhiteSmoke" stroke="DimGray" stroke-width=".2" /> + <g font-size="5" text-anchor="middle" fill="DimGray"> + <text x="23.5" y="228">$\hat Y$</text> + <text x="38" y="228">$Y$</text> + </g> + </g> + + <rect x="50" y="190" width="30" height="50" + stroke="DarkOliveGreen" stroke-width=".2" fill="none" /> + <g> + <rect x="57" y="197" width="5" height="33" fill="LavenderBlush" stroke="maroon" stroke-width=".2" /> + <rect x="55" y="195" width="5" height="5" fill="white" stroke="SlateGray" stroke-width=".2" /> + <rect x="55" y="200" width="5" height="28" fill="LavenderBlush" stroke="maroon" stroke-width=".2" /> + <rect x="70.5" y="196" width="5" height="33" fill="WhiteSmoke" stroke="DimGray" stroke-width=".2" /> + <g font-size="5" text-anchor="middle" fill="DimGray"> + <text x="58.5" y="238">$\hat Y$</text> + <text x="73" y="238">$Y$</text> + </g> + </g> + + <text fill="DimGray" x="95" y="220" text-anchor="middle" font-size="10"> + ... + </text> + + <rect x="10" y="245" width="100" height="45" fill="LavenderBlush" /> + + <g stroke="DarkOliveGreen" stroke-width=".2"> + <rect x="20" y="255" width="30" height="30" + fill="HoneyDew" /> + <line x1="25" x2="25" y1="255" y2="285" /> + <line x1="30" x2="30" y1="255" y2="285" /> + <text x="40" y="275" font-size="5" text-anchor="middle">...</text> + </g> + + <text font-size="5" fill="DimGray" x="80" y="275" text-anchor="middle"> + $W$ : modèle + </text> + + <g fill="none" stroke="DarkOliveGreen" stroke-width="1"> + <polyline points="22.5,230 22.5,255 20.5,253 22.5,255 24.5,253 22.5,255" /> + <polyline points="50,235 27.5,235 27.5,255 25.5,253 27.5,255 29.5,253 27.5,255" /> + </g> + + <polygon points="10,240 60,240 70,230 80,230 90,240 110,240 110,250 90,250 80,260 70,260 60,250 10,250" + stroke="DarkOliveGreen" stroke-width=".2" fill="honeydew" /> + <text fill="DarkOliveGreen" font-size="5" text-anchor="middle" x="75" y="240"> + Ridge + </text> + <text fill="DarkOliveGreen" font-size="5" x="60" y="247" text-anchor="middle"> + (avec imputation par la moyenne) + </text> + + <polygon points="10,160 80,160 110,190 110,290 10,290" + fill="none" stroke="SlateGray" stroke-width=".2" /> + </g> + + <g id="page-resultats"> + <rect x="120" y="190" width="80" height="100" fill="white" /> + <rect x="120" y="195" width="80" height="15" stroke="none" fill="WhiteSmoke" /> + + <text x="160" y="207" font-size="10" fill="DimGray" text-anchor="middle"> + Sortie + </text> + + <text x="125" y="230" font-size="5" fill="DimGray"> + RSMS : variables + </text> + + <text x="125" y="255" font-size="5" fill="DimGray"> + LSMR : modèles bootstrap + </text> + + <text x="125" y="280" font-size="5" fill="DimGray"> + Stacking : modèle Ridge + </text> + + <line x1="120" x2="200" y1="195" y2="195" stroke="SlateGray" stroke-width="1"/> + <line x1="120" x2="200" y1="210" y2="210" stroke="SlateGray" stroke-width=".2" /> + <line x1="120" x2="200" y1="215" y2="215" stroke="SlateGray" stroke-width=".2" /> + <line x1="120" x2="200" y1="240" y2="240" stroke="SlateGray" stroke-width=".2" /> + <line x1="120" x2="200" y1="265" y2="265" stroke="SlateGray" stroke-width=".2" /> + <rect x="120" y="190" width="80" height="100" + fill="none" stroke="SlateGray" stroke-width="0.2" /> + </g> +</svg> diff --git a/images/lsmrrsmsinference.svg b/images/lsmrrsmsinference.svg new file mode 100644 index 0000000..d4d96f3 --- /dev/null +++ b/images/lsmrrsmsinference.svg @@ -0,0 +1,475 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<svg + xmlns:dc="http://purl.org/dc/elements/1.1/" + xmlns:cc="http://creativecommons.org/ns#" + xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns:svg="http://www.w3.org/2000/svg" + xmlns="http://www.w3.org/2000/svg" + xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" + xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" + width="150mm" + height="50mm" + viewBox="71 133 832 239" + version="1.1" + id="svg5016" + sodipodi:docname="Diagramme1.svg" + inkscape:version="0.92.4 (5da689c313, 2019-01-14)"> + <metadata + id="metadata5022"> + <rdf:RDF> + <cc:Work + rdf:about=""> + <dc:format>image/svg+xml</dc:format> + <dc:type + rdf:resource="http://purl.org/dc/dcmitype/StillImage" /> + </cc:Work> + </rdf:RDF> + </metadata> + <defs + id="defs5020" /> + <sodipodi:namedview + pagecolor="#ffffff" + bordercolor="#666666" + borderopacity="1" + objecttolerance="10" + gridtolerance="10" + guidetolerance="10" + inkscape:pageopacity="0" + inkscape:pageshadow="2" + inkscape:window-width="1920" + inkscape:window-height="1080" + id="namedview5018" + showgrid="false" + inkscape:zoom="0.280633" + inkscape:cx="1016.6517" + inkscape:cy="-254.18323" + inkscape:window-x="0" + inkscape:window-y="0" + inkscape:window-maximized="1" + inkscape:current-layer="g4890" /> + <g + id="Arrière-plan" /> + <g + id="g4848" /> + <g + id="g4850" /> + <g + id="g4852" /> + <g + id="g4854" /> + <g + id="g5014"> + <g + id="g4862"> + <path + style="fill:#ffffff;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-opacity:1" + d="M 81.191136,293.837 H 148.263 l -12.54004,38 H 70.176878 Z" + id="polygon4856" + inkscape:connector-curvature="0" + sodipodi:nodetypes="ccccc" /> + <text + font-size="12.8" + style="font-style:normal;font-weight:normal;font-size:12.80000019px;font-family:sans-serif;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none" + x="106.05132" + y="320.49252" + id="text4860"> + <tspan + x="106.05132" + y="320.49252" + id="tspan4858">POST</tspan> + </text> + </g> + <g + id="g4872"> + <polygon + style="fill: #ffffff; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + points="748.242,285.837 902.214,285.837 882.56,339.837 728.588,339.837 " + id="polygon4864" /> + <text + font-size="12.8" + style="font-style:normal;font-weight:normal;font-size:12.80000019px;font-family:sans-serif;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none" + x="811.58362" + y="314.38007"> + <tspan + x="811.58362" + y="314.38007" + id="tspan4866">Tonalité</tspan> + </text> + <text + font-size="12.8" + style="font-style:normal;font-weight:normal;font-size:12.80000019px;font-family:sans-serif;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none" + x="811.58362" + y="330.38007"> + <tspan + x="811.58362" + y="330.38007" + id="tspan4868">multi-labels</tspan> + </text> + </g> + <g + id="g4890"> + <polygon + style="fill: #ffffff; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + points="633.727,264.044 689.121,312.837 633.727,361.63 578.333,312.837 " + id="polygon4874" /> + <text + font-size="12.8" + style="fill: #000000; fill-opacity: 1; stroke: none;text-anchor:middle;font-family:sans-serif;font-style:normal;font-weight:normal" + x="633.727" + y="316.737" + id="text4878"> + <tspan + x="633.727" + y="316.737" + id="tspan4876">Stacking</tspan> + </text> + <path + style="fill: #ffffff; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + d="M 552.427 148.117 C 584.947,138.617 601.207,135.45 633.727,135.45 C 666.247,135.45 682.507,138.617 715.027,148.117 L 715.027,198.783 C 682.507,208.283 666.247,211.45 633.727,211.45 C 601.207,211.45 584.947,208.283 552.427,198.783 L 552.427,148.117z" + id="path4880" /> + <path + style="fill: none; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + d="M 552.427 148.117 C 584.947,157.617 601.207,160.783 633.727,160.783 C 666.247,160.783 682.507,157.617 715.027,148.117" + id="path4882" /> + <text + font-size="12.7998" + style="font-style:normal;font-weight:normal;font-size:12.79979992px;font-family:sans-serif;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none" + x="633.72699" + y="183.40976" + id="text4888"> + <tspan + x="633.72699" + y="183.40976" + id="tspan4884">Modèle</tspan> + </text> + <text + font-size="12.7998" + style="font-style:normal;font-weight:normal;font-size:12.79979992px;font-family:sans-serif;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none" + x="633.72699" + y="199.40976" + id="text4888"> + <tspan + x="633.72699" + y="199.40976" + id="tspan4886">stacking</tspan> + </text> + </g> + <g + id="g4926"> + <g + id="g4898"> + <polygon + style="fill: #ffffff; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + points="451.715,297.874 497.613,334.387 451.715,370.901 405.818,334.387 " + id="polygon4892" /> + <text + font-size="12.8" + style="fill: #000000; fill-opacity: 1; stroke: none;text-anchor:middle;font-family:sans-serif;font-style:normal;font-weight:normal" + x="451.715" + y="338.287" + id="text4896"> + <tspan + x="451.715" + y="338.287" + id="tspan4894">LSMR</tspan> + </text> + </g> + <g + id="g4906"> + <polygon + style="fill: #ffffff; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + points="451.715,276.324 497.613,312.837 451.715,349.351 405.818,312.837 " + id="polygon4900" /> + <text + font-size="12.8" + style="fill: #000000; fill-opacity: 1; stroke: none;text-anchor:middle;font-family:sans-serif;font-style:normal;font-weight:normal" + x="451.715" + y="316.737" + id="text4904"> + <tspan + x="451.715" + y="316.737" + id="tspan4902">LSMR</tspan> + </text> + </g> + <g + id="g4914"> + <polygon + style="fill: #ffffff; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + points="451.715,254.774 497.613,291.287 451.715,327.801 405.818,291.287 " + id="polygon4908" /> + <text + font-size="12.8" + style="font-style:normal;font-weight:normal;font-size:12.80000019px;font-family:sans-serif;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none" + x="451.715" + y="300.11615" + id="text4912"> + <tspan + x="451.715" + y="300.11615" + id="tspan4910">LSMR</tspan> + </text> + </g> + <path + style="fill: #ffffff; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + d="M 365.565 148.117 C 400.025,138.617 417.255,135.45 451.715,135.45 C 486.175,135.45 503.405,138.617 537.865,148.117 L 537.865,198.783 C 503.405,208.283 486.175,211.45 451.715,211.45 C 417.255,211.45 400.025,208.283 365.565,198.783 L 365.565,148.117z" + id="path4916" /> + <path + style="fill: none; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + d="M 365.565 148.117 C 400.025,157.617 417.255,160.783 451.715,160.783 C 486.175,160.783 503.405,157.617 537.865,148.117" + id="path4918" /> + <text + font-size="12.7998" + style="font-style:normal;font-weight:normal;font-size:12.79979992px;font-family:sans-serif;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none" + x="451.715" + y="181.76672"> + <tspan + x="451.715" + y="181.76672" + id="tspan4920">Modèles</tspan> + </text> + <text + font-size="12.7998" + style="font-style:normal;font-weight:normal;font-size:12.79979992px;font-family:sans-serif;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none" + x="451.715" + y="197.76672"> + <tspan + x="451.715" + y="197.76672" + id="tspan4922">bootstrap</tspan> + </text> + </g> + <g + id="g4946"> + <path + style="fill:#ffffff;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:2;stroke-opacity:1" + d="m 183.17656,287.837 149.52625,0 17.37119,25 -17.37119,25 -149.52625,0 -20.42256,-25 z" + id="path4928" + inkscape:connector-curvature="0" + sodipodi:nodetypes="ccccccc" /> + <text + font-size="12.8" + style="font-style:normal;font-weight:normal;font-size:12.80000019px;font-family:sans-serif;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none" + x="256.414" + y="313.17868" + id="text4934"> + <tspan + x="256.414" + y="313.17868" + id="tspan4930">Reconnaissance</tspan> + </text> + <text + font-size="12.8" + style="font-style:normal;font-weight:normal;font-size:12.80000019px;font-family:sans-serif;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none" + x="256.414" + y="329.17868" + id="text4934"> + <tspan + x="256.414" + y="329.17868" + id="tspan4932">des variables</tspan> + </text> + <path + style="fill: #ffffff; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + d="M 168.914 148.117 C 203.914,138.617 221.414,135.45 256.414,135.45 C 291.414,135.45 308.914,138.617 343.914,148.117 L 343.914,198.783 C 308.914,208.283 291.414,211.45 256.414,211.45 C 221.414,211.45 203.914,208.283 168.914,198.783 L 168.914,148.117z" + id="path4936" /> + <path + style="fill: none; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + d="M 168.914 148.117 C 203.914,157.617 221.414,160.783 256.414,160.783 C 291.414,160.783 308.914,157.617 343.914,148.117" + id="path4938" /> + <text + font-size="12.7998" + style="font-style:normal;font-weight:normal;font-size:12.79979992px;font-family:sans-serif;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none" + x="256.414" + y="181.47302" + id="text4944"> + <tspan + x="256.414" + y="181.47302" + id="tspan4940">Variables</tspan> + </text> + <text + font-size="12.7998" + style="font-style:normal;font-weight:normal;font-size:12.79979992px;font-family:sans-serif;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none" + x="256.414" + y="197.47302" + id="text4944"> + <tspan + x="256.414" + y="197.47302" + id="tspan4942">sélectionnées</tspan> + </text> + </g> + <g + id="g4952"> + <line + style="fill: none; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + x1="141.348" + y1="312.837" + x2="153.018" + y2="312.837" + id="line4948" /> + <polygon + style="fill: #000000; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + points="160.518,312.837 150.518,317.837 153.018,312.837 150.518,307.837 " + id="polygon4950" /> + </g> + <g + id="g4958"> + <line + style="fill: none; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + x1="350.073" + y1="312.837" + x2="396.082" + y2="312.837" + id="line4954" /> + <polygon + style="fill: #000000; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + points="403.582,312.837 393.582,317.837 396.082,312.837 393.582,307.837 " + id="polygon4956" /> + </g> + <g + id="g4964"> + <path + style="fill:none;stroke:#000000;stroke-width:2;stroke-opacity:1" + d="M 342.57075,302.26155 396.229,292.97198" + id="line4960" + inkscape:connector-curvature="0" + sodipodi:nodetypes="cc" /> + <polygon + style="fill: #000000; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + points="403.615,291.674 394.632,298.33 396.229,292.972 392.901,288.48 " + id="polygon4962" /> + </g> + <g + id="g4970"> + <path + style="fill:none;stroke:#000000;stroke-width:2;stroke-opacity:1" + d="M 342.33603,323.41344 396.229,332.702" + id="line4966" + inkscape:connector-curvature="0" + sodipodi:nodetypes="cc" /> + <polygon + style="fill: #000000; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + points="403.615,334 392.901,337.194 396.229,332.702 394.632,327.345 " + id="polygon4968" /> + </g> + <g + id="g4976"> + <line + style="fill: none; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + x1="497.613" + y1="291.287" + x2="576.225" + y2="303.733" + id="line4972" /> + <polygon + style="fill: #000000; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + points="583.632,304.906 572.973,308.281 576.225,303.733 574.537,298.404 " + id="polygon4974" /> + </g> + <g + id="g4982"> + <line + style="fill: none; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + x1="497.613" + y1="312.837" + x2="567.596" + y2="312.837" + id="line4978" /> + <polygon + style="fill: #000000; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + points="575.096,312.837 565.096,317.837 567.596,312.837 565.096,307.837 " + id="polygon4980" /> + </g> + <g + id="g4988"> + <line + style="fill: none; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + x1="497.613" + y1="334.387" + x2="576.225" + y2="321.941" + id="line4984" /> + <polygon + style="fill: #000000; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + points="583.632,320.768 574.537,327.271 576.225,321.941 572.973,317.394 " + id="polygon4986" /> + </g> + <g + id="g4994"> + <line + style="fill: none; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + x1="690.121" + y1="312.837" + x2="728.034" + y2="312.837" + id="line4990" /> + <polygon + style="fill: #000000; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + points="735.534,312.837 725.534,317.837 728.034,312.837 725.534,307.837 " + id="polygon4992" /> + </g> + <g + id="g5000"> + <line + style="fill: none; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + x1="256.414" + y1="211.45" + x2="256.414" + y2="278.101" + id="line4996" /> + <polygon + style="fill: #000000; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + points="256.414,285.601 251.414,275.601 256.414,278.101 261.414,275.601 " + id="polygon4998" /> + </g> + <g + id="g5006"> + <line + style="fill: none; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + x1="451.715" + y1="211.45" + x2="451.715" + y2="245.038" + id="line5002" /> + <polygon + style="fill: #000000; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + points="451.715,252.538 446.715,242.538 451.715,245.038 456.715,242.538 " + id="polygon5004" /> + </g> + <g + id="g5012"> + <line + style="fill: none; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + x1="633.727" + y1="211.45" + x2="633.727" + y2="254.308" + id="line5008" /> + <polygon + style="fill: #000000; fill-opacity: 1; stroke-opacity: 1; stroke-width: 2; stroke: #000000" + fill-rule="evenodd" + points="633.727,261.808 628.727,251.808 633.727,254.308 638.727,251.808 " + id="polygon5010" /> + </g> + </g> +</svg> diff --git a/images/nemenyi.R b/images/nemenyi.R new file mode 100644 index 0000000..f7e4729 --- /dev/null +++ b/images/nemenyi.R @@ -0,0 +1,7 @@ +#!/usr/bin/env Rscript +source (sprintf ("%s/images/lsmr_global_tuning.R", Sys.getenv ("ABS_TOP_SRCDIR"))) +print_win_lose_tie_plot () +filename <- Sys.getenv ("OUTPUT") +svg (filename, width = 5, height = 5) +cd_analysis () +dev.off () diff --git a/images/rsms_1.R b/images/rsms_1.R new file mode 100644 index 0000000..df07a1d --- /dev/null +++ b/images/rsms_1.R @@ -0,0 +1,69 @@ +load (sprintf ("%s/data/rsms_test.Rdata", Sys.getenv ("ABS_TOP_SRCDIR"))) + +Sys.setlocale ("LC_ALL", "fr_FR.UTF-8") + +#' Print the graphs for the features. +#' @return the graph. +#' @export +features_graph <- function () { + library ("magrittr") + data <- (test + %>% dplyr::filter (frac_labeled == 0.3, + frac_labels == 1, + algorithm %in% c ("formulas", "mifs", "rfs", "sfus"), + dataset %in% c ("atp1d", "atp7d", "edm", "enb", "oes10", "oes97", "osales", "scpf", "sf1", "sf2", "wq"), + !is.na (error)) + %>% dplyr::mutate (algorithm = ifelse (algorithm == "formulas", "\\textbf{RSMS}", algorithm)) + %>% dplyr::mutate (algorithm = ifelse (algorithm == "mifs", "MIFS", algorithm)) + %>% dplyr::mutate (algorithm = ifelse (algorithm == "rfs", "RFS", algorithm)) + %>% dplyr::mutate (algorithm = ifelse (algorithm == "sfus", "SFUS", algorithm)) + %>% dplyr::select (dataset, algorithm, frac_features, error) + %>% dplyr::group_by (dataset, algorithm, frac_features) + %>% dplyr::summarize (n = dplyr::n (), + mean = mean (error), + sd = sd (error), + min = min (error), + max = max (error), + median = median (error), + q1 = quantile (error, 0.25), + q3 = quantile (error, 0.75)) + %>% dplyr::ungroup ()) + arrange <- function (...) { + gridExtra::grid.arrange (..., layout_matrix = rbind ( + c (1, 2, 3), + c (4, 5, 6), + c (7, 8, 9), + c (10, 11, 11) + )) + } + do.call (arrange, lapply ((data + %>% dplyr::select (dataset) + %>% dplyr::distinct ())$dataset, function (dataset_name) { + with_legend <- (data + %>% dplyr::filter (dataset == dataset_name) + %>% dplyr::mutate (ymin = mean - sd, ymax = max + sd) + %>% dplyr::select (Algorithme = algorithm, + `Variables` = frac_features, + `aRMSE moyenne` = mean, ymin, ymax) + %>% ggplot2::ggplot (ggplot2::aes (x = `Variables`, + y = `aRMSE moyenne`, + color = Algorithme, + linetype = Algorithme)) + + ggplot2::geom_line () + + ggplot2::ggtitle (dataset_name) + + ggplot2::scale_x_continuous (labels = scales::percent) + + ggplot2::scale_color_manual (limits = c ("\\textbf{RSMS}", "MIFS", "SFUS", "RFS"), + values = c ("black", "#e69f00", "#56b4e9", "#009e73")) + + ggplot2::scale_linetype_manual (limits = c ("\\textbf{RSMS}", "MIFS", "SFUS", "RFS"), + values = c ("solid", "dashed", "longdash", "dotdash"))) + if (dataset_name == "wq") { + with_legend + } else { + with_legend + ggplot2::theme (legend.position = "none") + } + })) +} + +plot <- features_graph () +filename <- Sys.getenv ("OUTPUT") +ggplot2::ggsave (filename, plot, device = "svg", width = 6, height = 8) diff --git a/images/rsms_2.R b/images/rsms_2.R new file mode 100644 index 0000000..8be2cf0 --- /dev/null +++ b/images/rsms_2.R @@ -0,0 +1,58 @@ +load (sprintf ("%s/data/rsms_test.Rdata", Sys.getenv ("ABS_TOP_SRCDIR"))) + +Sys.setlocale ("LC_ALL", "fr_FR.UTF-8") + +#' Print the graphs for label selection +#' @return the graph. +#' @export +labels_graph <- function () { + library ("magrittr") + data <- (test + %>% dplyr::filter (frac_labeled == 0.3, + frac_features == 0.3, + algorithm == "formulas", + dataset %in% c ("atp1d", "atp7d", "edm", "enb", "oes10", "oes97", "osales", "scpf", "sf1", "sf2", "wq"), + !is.na (error)) + %>% dplyr::select (dataset, frac_labels, error) + %>% dplyr::group_by (dataset, frac_labels) + %>% dplyr::summarize (n = dplyr::n (), + mean = mean (error), + sd = sd (error), + min = min (error), + max = max (error), + median = median (error), + q1 = quantile (error, 0.25), + q3 = quantile (error, 0.75)) + %>% dplyr::ungroup ()) + arrange <- function (...) { + gridExtra::grid.arrange (..., layout_matrix = rbind ( + c (1, 2, 3), + c (4, 5, 6), + c (7, 8, 9), + c (10, 11, 11) + )) + } + do.call (arrange, lapply ((data + %>% dplyr::select (dataset) + %>% dplyr::distinct ())$dataset, function (dataset_name) { + with_legend <- (data + %>% dplyr::filter (dataset == dataset_name) + %>% dplyr::mutate (ymin = mean - sd, ymax = max + sd) + %>% dplyr::select (`Labels sélectionnées` = frac_labels, + `aRMSE moyenne` = mean, ymin, ymax) + %>% ggplot2::ggplot (ggplot2::aes (x = `Labels sélectionnées`, + y = `aRMSE moyenne`)) + + ggplot2::geom_line () + + ggplot2::ggtitle (dataset_name) + + ggplot2::scale_x_continuous (labels = scales::percent)) + if (dataset_name == "wq") { + with_legend + } else { + with_legend + ggplot2::theme (legend.position = "none") + } + })) +} + +plot <- labels_graph () +filename <- Sys.getenv ("OUTPUT") +ggplot2::ggsave (filename, plot, device = "svg", width = 6, height = 8) diff --git a/images/rsms_3.R b/images/rsms_3.R new file mode 100644 index 0000000..52a77e8 --- /dev/null +++ b/images/rsms_3.R @@ -0,0 +1,94 @@ +load (sprintf ("%s/data/rsms_test.Rdata", Sys.getenv ("ABS_TOP_SRCDIR"))) + +Sys.setlocale ("LC_ALL", "fr_FR.UTF-8") + +#' Print the graphs for the interest of label selection +#' @return the graph. +#' @export +with_labels_graph <- function () { + library ("magrittr") + lower_number <- tibble::tibble ( + dataset = + c ("atp1d", + "atp7d", + "edm", + "enb", + "oes10", + "oes97", + "osales", + "scpf", + "sf1", + "sf2", + "wq"), + frac_labeled_restricted = + c (0.8, + 0.8, + 0.6, + 0.6, + 0.8, + 0.8, + 0.8, + 0.6, + 0.6, + 0.6, + 0.8)) + data <- (test + %>% dplyr::filter (frac_labeled == 0.3, + algorithm == "formulas", + dataset %in% c ("atp1d", "atp7d", "edm", "enb", "oes10", "oes97", "osales", "scpf", "sf1", "sf2", "wq"), + !is.na (error)) + %>% dplyr::inner_join (lower_number) + %>% dplyr::mutate (full = (frac_labels == 1), + restricted = (frac_labels == frac_labeled_restricted)) + %>% dplyr::filter (full | restricted) + %>% dplyr::mutate (algorithm = ifelse (full, "RSMS (tous labels)", "RSMS (restreint)")) + %>% dplyr::select (dataset, frac_features, algorithm, error) + %>% dplyr::group_by (dataset, frac_features, algorithm) + %>% dplyr::summarize (n = dplyr::n (), + mean = mean (error), + sd = sd (error), + min = min (error), + max = max (error), + median = median (error), + q1 = quantile (error, 0.25), + q3 = quantile (error, 0.75)) + %>% dplyr::ungroup ()) + arrange <- function (...) { + gridExtra::grid.arrange (..., layout_matrix = rbind ( + c (1, 2, 3), + c (4, 5, 6), + c (7, 8, 9), + c (10, 11, 11) + )) + } + do.call (arrange, lapply ((data + %>% dplyr::select (dataset) + %>% dplyr::distinct ())$dataset, function (dataset_name) { + with_legend <- (data + %>% dplyr::filter (dataset == dataset_name) + %>% dplyr::mutate (ymin = mean - sd, ymax = max + sd) + %>% dplyr::select (Algorithme = algorithm, + `Variables` = frac_features, + `aRMSE moyenne` = mean, ymin, ymax) + %>% ggplot2::ggplot (ggplot2::aes (x = `Variables`, + y = `aRMSE moyenne`, + color = Algorithme, + linetype = Algorithme)) + + ggplot2::geom_line () + + ggplot2::ggtitle (dataset_name) + + ggplot2::scale_x_continuous (labels = scales::percent) + + ggplot2::scale_color_manual (limits = c ("RSMS (restreint)", "RSMS (tous labels)"), + values = c ("black", "#e69f00", "#56b4e9", "#009e73")) + + ggplot2::scale_linetype_manual (limits = c ("RSMS (restreint)", "RSMS (tous labels)"), + values = c ("solid", "dashed", "longdash", "dotdash"))) + if (dataset_name == "wq") { + with_legend + } else { + with_legend + ggplot2::theme (legend.position = "none") + } + })) +} + +plot <- with_labels_graph () +filename <- Sys.getenv ("OUTPUT") +ggplot2::ggsave (filename, plot, device = "svg", width = 6, height = 8) diff --git a/images/rsms_4.R b/images/rsms_4.R new file mode 100644 index 0000000..94045d2 --- /dev/null +++ b/images/rsms_4.R @@ -0,0 +1,42 @@ +load (sprintf ("%s/data/rsms_protocol_4.Rdata", Sys.getenv ("ABS_TOP_SRCDIR"))) + +Sys.setlocale ("LC_ALL", "fr_FR.UTF-8") + +#' Print the convergence graphs +#' @return the graphs +#' @export +convergence_graph <- function () { + library ("magrittr") + data <- (protocol_4 + %>% dplyr::group_by (dataset, maxiter) + %>% dplyr::summarize (mloss = mean (loss), + sloss = sd (loss)) + %>% dplyr::mutate (dataset, + `Nombre d'itérations` = maxiter, + `Coût` = mloss, + mini = mloss - sloss, + maxi = mloss + sloss)) + arrange <- function (...) { + gridExtra::grid.arrange (..., layout_matrix = rbind ( + c (1, 1, 2, 2, 3, 3), + c (4, 4, 5, 5, 6, 6), + c (7, 7, 8, 8, 9, 9), + c (10, 10, 10, 11, 11, 11) + )) + } + do.call (arrange, lapply (c ("atp1d", "atp7d", "edm", "enb", "oes10", "oes97", "osales", "scpf", "sf1", "sf2", "wq"), function (dataset_name) { + (data + %>% dplyr::filter (dataset == dataset_name) + %>% ggplot2::ggplot (ggplot2::aes (x = `Nombre d'itérations`, + y = `Coût`, + ymin = mini, + ymax = maxi)) + + ggplot2::geom_line () + + ggplot2::geom_ribbon (alpha = 0.2) + + ggplot2::ggtitle (dataset_name)) + })) +} + +plot <- convergence_graph () +filename <- Sys.getenv ("OUTPUT") +ggplot2::ggsave (filename, plot, device = "svg", width = 6, height = 8) diff --git a/images/twomoons.R b/images/twomoons.R new file mode 100755 index 0000000..c825abd --- /dev/null +++ b/images/twomoons.R @@ -0,0 +1,50 @@ +#!/usr/bin/env Rscript +t <- seq (0, 1, length.out = 101) +labeled <- c (rep (0, 100), 1) +upper_x <- cos (t * pi) + 0.5 +upper_y <- sin (t * pi) +lower_x <- -upper_x +lower_y <- -upper_y + +`%>%` <- magrittr::`%>%` + +data <- (tibble::tibble (x = upper_x, y = upper_y, + label = c (rep ("unlabeled", 100), "+"), + `semi-supervised solution` = "+") + %>% rbind (tibble::tibble (x = lower_x, y = lower_y, + label = c (rep ("unlabeled", 100), "-"), + `semi-supervised solution` = "-")) + %>% dplyr::mutate (noise_x = 0.1 * rnorm (dplyr::n ()), + noise_y = 0.1 * rnorm (dplyr::n ())) + %>% dplyr::mutate (x = x + noise_x, y = y + noise_y) + %>% dplyr::mutate (`naive solution` = ifelse (x <= 0, "+", "-"))) + +scales <- function (plot) { + (plot + + ggplot2::scale_size_manual (values = c ("unlabeled" = 1, "+" = 3, "-" = 3)) + + ggplot2::scale_shape_manual (values = c ("+" = 16, "-" = 17, "unlabeled" = 3)) + + ggplot2::scale_color_manual (values = c ("+" = "#E69F00", "-" = "#56B4E9", "unlabeled" = "#009E73")) + + ggplot2::theme_void () + + ggplot2::theme(legend.position="none") + + ggplot2::coord_fixed ()) +} + +question <- ((data + %>% ggplot2::ggplot (ggplot2::aes (x = x, y = y, shape = label, color = label, size = label)) + + ggplot2::geom_point ()) + %>% scales ()) + +naive_answer <- ((data + %>% ggplot2::ggplot (ggplot2::aes (x = x, y = y, shape = `naive solution`, color = `naive solution`)) + + ggplot2::geom_point () + + ggplot2::geom_vline (xintercept = 0)) + %>% scales ()) + +semi_supervised_answer <- ((data + %>% ggplot2::ggplot (ggplot2::aes (x = x, y = y, shape = `semi-supervised solution`, color = `semi-supervised solution`)) + + ggplot2::geom_point ()) + %>% scales ()) + +plot <- gridExtra::arrangeGrob (question, gridExtra::arrangeGrob (naive_answer, semi_supervised_answer, ncol = 2), nrow = 2) +filename <- Sys.getenv ("OUTPUT") +ggplot2::ggsave (filename, plot, device = "svg", width = 3.5, height = 3.5) diff --git a/images/wilcoxon.R b/images/wilcoxon.R new file mode 100644 index 0000000..2d197e2 --- /dev/null +++ b/images/wilcoxon.R @@ -0,0 +1,6 @@ +#!/usr/bin/env Rscript +source (sprintf ("%s/images/lsmr_global_tuning.R", Sys.getenv ("ABS_TOP_SRCDIR"))) +print_win_lose_tie_plot () +plot <- print_win_lose_tie_plot () +filename <- Sys.getenv ("OUTPUT") +ggplot2::ggsave (filename, plot, device = "svg", width = 5, height = 5) diff --git a/manuscrit.html b/manuscrit.html new file mode 100644 index 0000000..24b5061 --- /dev/null +++ b/manuscrit.html @@ -0,0 +1,9309 @@ +<?xml version="1.0" encoding="utf-8"?> +<html xmlns="http://www.w3.org/1999/xhtml" + xmlns:m="http://planete-kraus.eu/ns/manuscrit" + xmlns:h="http://h4sp.planete-kraus.eu/ns/h4sp" + xmlns:b="http://h4sp.planete-kraus.eu/ns/bibliography" + xmlns:alg="http://h4sp.planete-kraus.eu/ns/algorithm" + xml:lang="fr"> + <head> + <title> + Apprentissage semi-supervisé pour la régression multi-labels : + Application à l’annotation automatique de pneumatiques. + </title> + <m:author email="vivien@planete-kraus.eu"> + Vivien <h:small-caps>Kraus</h:small-caps> + </m:author> + <m:page-de-garde> + <m:numéro-ordre-nnt>2021LYSE1052</m:numéro-ordre-nnt> + <m:page-de-garde-titre>Thèse de doctorat de l’université de Lyon</m:page-de-garde-titre> + <m:l-université>l’Université Claude Bernard Lyon 1</m:l-université> + <m:école-doctorale>École Doctorale ED512 <br/> Informatique et Mathématiques (InfoMaths)</m:école-doctorale> + <m:spécialité>Informatique</m:spécialité> + <m:date-soutenance>12/03/2021</m:date-soutenance> + <m:jury> + <m:membre grade="Professeur" + affiliation="Université de Lorraine" + rôle="Rapporteur"> + Mme Marianne <h:small-caps>Clausel</h:small-caps> + </m:membre> + <m:membre grade="Professeur" + affiliation="Université Clermont-Auvergne" + rôle="Rapporteur"> + M. Engelbert <h:small-caps>Mephu Nguifo</h:small-caps> + </m:membre> + <m:membre grade="Professeur" + affiliation="Université Lyon 1" + rôle="Examinateur"> + M. Hamamache <h:small-caps>Kheddouci</h:small-caps> + </m:membre> + <m:membre grade="Professeur" + affiliation="Université de Nantes" + rôle="Examinatrice"> + Mme Pascale <h:small-caps>Kuntz</h:small-caps> + </m:membre> + <m:membre grade="Maître de conférences" + affiliation="Université d’Évry" + rôle="Examinatrice"> + Mme Farida <h:small-caps>Zehraoui</h:small-caps> + </m:membre> + <m:membre grade="MCF-HDR" + affiliation="Université Lyon 1" + rôle="Directeur de thèse"> + M. Khalid <h:small-caps>Benabdeslem</h:small-caps> + </m:membre> + <m:membre grade="Responsable R&D" + affiliation="Lizeo IT" + rôle="Invité"> + M. Bruno <h:small-caps>Canitia</h:small-caps> + </m:membre> + </m:jury> + </m:page-de-garde> + </head> + <body> + <m:résumé> + <p> + Avec l’avènement et le développement rapide des technologies + numériques, les données sont devenues à la fois un bien + précieux et très abondant. Cependant, avec une telle + profusion, se posent des questions relatives à la qualité et + l'étiquetage de ces données. En effet, à cause de + l’augmentation des volumes de données disponibles, alors que + le coût de l'étiquetage par des experts humains reste très + important, il est de plus en plus nécessaire de pouvoir + renforcer l’apprentissage semi-supervisé grâce l'exploitation + des données non-labellisées. Ce problème est d’autant plus + marqué dans le cas de l’apprentissage multi-labels, et en + particulier pour la régression, où chaque unité statistique + est guidée par plusieurs cibles différentes, qui prennent la + forme de scores numériques. + </p> + <p> + C'est dans ce cadre fondamental, que s'inscrit cette + thèse. Tout d'abord, nous commençons par proposer une méthode + d’apprentissage pour la régression semi-supervisée, que nous + mettons à l’épreuve à travers une étude expérimentale + détaillée. Grâce à cette nouvelle méthode, nous présentons une + deuxième contribution, plus adaptée au contexte + multi-labels. Nous montrons également son efficacité par une + étude comparative, sur des jeux de données issues de la + littérature. Par ailleurs, la dimensionnalité du problème + demeure toujours la difficulté de l'apprentissage automatique, + et sa réduction suscite l'intérêt de plusieurs chercheurs dans + la communauté. Une des tâches majeures répondant à cette + problématique est la sélection de variables, que nous + proposons d'étudier ici dans un cadre complexe: + semi-supervisé, multi-labels et pour la régression. + </p> + </m:résumé> + <m:mots-clés> + <m:mot-clé>apprentissage semi-supervisé</m:mot-clé> + <m:mot-clé>apprentissage multi-labels</m:mot-clé> + <m:mot-clé>régression</m:mot-clé> + <m:mot-clé>régularisation Laplacienne</m:mot-clé> + <m:mot-clé>sélection de variables</m:mot-clé> + <m:mot-clé>sélection de labels</m:mot-clé> + <m:mot-clé>optimisation</m:mot-clé> + </m:mots-clés> + <m:abstract xml:lang="en"> + <p> + With the advent and rapid growth of digital technologies, data + has become a precious asset as well as plentiful. However, + with such an abundance come issues about data quality and + labelling. Because of growing numbers of available data + volumes, while human expert labelling is still important, it + is more and more necessary to reinforce semi-supervised + learning with the exploitation of unlabeled data. This problem + is all the more noticeable in the multi-label learning + framework, and in particular for regression, where each + statistical unit is guided by many different targets, taking + the form of numerical scores. + </p> + <p> + This thesis focuses on this fundamental framework. First, we + begin by proposing a method for semi-supervised regression + learning, that we challenge through a detailed experimental + study. Thanks to this new method, we present a second + contribution, more fitted to the multi-label framework. We + also show its efficiency with a comparative study on + literature data sets. Furthermore, the problem dimension is + always a pain point of machine learning, and reducing it + sparks the interest of many researchers. Feature selection is + one of the major tasks addressing this problems, and we + propose to study it here in a complex framework: for + semi-supervised, multi-label regression. + </p> + <p> + Finally, an experimental validation is proposed on a real + problem about automatic annotation of tires, to tackle the + needs expressed by the industrial partner of this thesis. + </p> + </m:abstract> + <m:keywords xml:lang="en"> + <m:keyword>semi-supervised learning</m:keyword> + <m:keyword>multi-label learning</m:keyword> + <m:keyword>regression</m:keyword> + <m:keyword>Laplacian regularization</m:keyword> + <m:keyword>feature selection</m:keyword> + <m:keyword>label selection</m:keyword> + <m:keyword>optimization</m:keyword> + </m:keywords> + <h:tableofcontents /> + <h:listoffigures /> + <h:listoftables /> + <h:listofalgorithms /> + <h1>Introduction générale</h1> + <h2>Contexte et motivation</h2> + <p> + L'apprentissage automatique est une discipline de l'intelligence + artificielle qui consiste à extraire à partir de données + complexes, des connaissances utiles pour la prise de décision + dans différents domaines d'application. Ces données peuvent + êtres présentées sous différentes formes : observations, objets, + transactions, signaux, graphes, textes, etc. + </p> + <p> + L'apprentissage automatique à partir des données vise à extraire + des connaissances directement à partir des observations que l'on + peut effectuer de l'environnement. Selon le cadre d'application, + les observations peuvent être très différentes. Il peut s'agir + de textes et d'images, par exemple, afin d'effectuer de la + classification de documents textuels ou de la reconnaissance + d'images. + </p> + <p> + Dans ce contexte, le principe général consiste à modéliser une + fonction statistique qui nous permet de résoudre le problème + abordé. Cette modélisation est jugée pertinente si elle permet + de généraliser la décision à de nouvelles formes de données + inconnues au modèle, a priori. + </p> + <p> + Dans le cadre de cette thèse, la modélisation que nous cherchons + à mettre en œuvre se présente sous la forme <h:eq>y = f + (x)</h:eq> où <h:eq>x</h:eq> représente les variables + explicatives du problème, par exemple les mots employés dans un + texte. <h:eq>y</h:eq> représente la variable cible à expliquer, + appelée aussi cible ou label, c'est-à-dire celle que l'on + cherche à expliquer : le ou les thèmes du document textuel. + </p> + <p> + Pour trouver cette fonction <h:eq>f</h:eq>, il y a plusieurs + régimes d'application. Si la variable cible est complètement + connue (pour toutes les observations), il s'agit d'apprentissage + supervisé. Si elle est inconnue, il s'agit d'apprentissage non + supervisé. Dans le cas qui nous intéresse, elle n'est que + partiellement connue, ce qui définit l'apprentissage + semi-supervisé. + </p> + <p> + Selon le type d'apprentissage envisagé, nous pouvons utiliser un + certain nombre d'algorithmes, c'est-à-dire une fonction qui à + partir des données construit le modèle <h:eq>f</h:eq>. Dans le + cadre qui nous intéresse ici, l'algorithme consiste à minimiser + une fonction de coût, en cherchant le modèle parmi une certaine + classe de fonctions. La fonction de coût accumule donc les + erreurs commises sur l'ensemble du jeu de données. En la + minimisant, l'objectif est d'obtenir le modèle le plus adapté à + la distribution des données. + </p> + <p> + Par ailleurs, en apprentissage automatique, l'extraction de + variables permet de synthétiser l'information contenue dans les + caractéristiques du problème, de façon à en obtenir de nouvelles + où chaque observation est décrite différemment. Cela permet + d'effectuer une réduction de dimension. D'autre part, la + sélection de variables est un cas particulier, pour lequel + chaque variable obtenue est une variable de description de + l'observation, mais seules les variables pertinentes sont + sélectionnées. La sélection de variables a donc un avantage + considérable sur l'extraction de variables, puisqu'elle permet + d'avoir un modèle plus interprétable. Par exemple, dans le cas + de l'apprentissage à partir de données textuelles, elle permet + de sélectionner le champ lexical du thème qui nous intéresse, ce + qui est en soi un apport de connaissances. + </p> + <p> + La performance des algorithmes d'apprentissage en + classification, régression ou sélection de variables, s'évalue + sur les données n'ayant pas servi à la construction du + modèle. Si la fonction résultante <h:eq>f</h:eq> est performante + sur ces données, elle permettra de généraliser la connaissance, + et ainsi conduire à une décision fiable. Principalement, on + distingue deux obstacles qui s'opposent à la généralisation de + la fonction de décision : le <emph>sous-apprentissage</emph>, + pour lequel <h:eq>f</h:eq> ignore l'information utile des + données, et le <emph>sur-apprentissage</emph>, qui donne trop + d'importance au bruit dans les données. Le sous-apprentissage + est assez simple à détecter, puisque la fonction <h:eq>f</h:eq> + n'est pas performante sur les données connues. + </p> + <p> + Il est parfois possible de contrer l'effet du sur-apprentissage, + en introduisant une régularisation explicite dans l'algorithme + préconisé. Ainsi, celui-ci minimise l'erreur accumulée sur + l'ensemble des données, mais tente également de minimiser la + complexité du modèle sous-jacent. Une certaine définition de la + complexité du modèle informe le choix de la régularisation + employée. + </p> + <p> + Selon la nature de la variable cible, différents algorithmes + peuvent être envisagés. Dans le cas de la régression, cette + variable est de nature continue, contrairement à la + classification dans laquelle elle est discrète. De plus, dans le + cas d'un apprentissage multi-labels, l'espace de cette variable + cible s'élargit et rejoint celui des variables explicatives dans + toute sa complexité liée à la corrélation, au bruit et à la + difficulté à modéliser la fonction de décision avec de multiples + cibles, simultanément. C'est enfin, dans ce cadre complexe, que + s'inscrit l'aspect fondamental de cette thèse. + </p> + <p> + Sur l'aspect applicatif, cette thèse s’inscrit dans le cadre + d’une convention CIFRE entre le laboratoire LIRIS et la société + Lizeo IT du groupe Lizeo <h:fn>Cette thèse fait l'objet d'une + "Convention Industrielle de Formation par la Recherche" (CIFRE) + proposée par l’Agence Nationale de la Recherche Technique + (ANRT). Ce mode de financement consiste en un partenariat entre + une entreprise, ici Lizeo IT du groupe Lizeo et une université + (ici, l'université Claude Bernard Lyon 1 , UCBL).</h:fn>. En + effet, dans le cadre de ses activités, l'entreprise récolte de + nombreux documents textuels issus de multiples sources et + décrivant les qualités des pneumatiques. Chacune de ces + caractéristiques représente un score d'appréciation continu + (sous forme d'une note) : ce sont donc des variables cible, + réelles. La connaissance extraite de ces données d'appréciation + sont d'une très grande importance pour les manufacturiers et les + distributeurs, mais l'annotation manuelle est très délicate, + puisqu'elle requiert des connaissances vis-à-vis des produits, + et coûteuse puisqu'elle doit s'effectuer sur plusieurs critères + différents. Par conséquent, l'apprentissage doit s'inscrire + dans le cadre semi-supervisé pour la régression multi-labels. + </p> + <h2>Contributions</h2> + <p> + Tout d'abord, nous avons commencé à aborder le problème de la + régression dans le cadre mono-label. Pour ce faire, nous nous + sommes fondés sur deux algorithmes représentatifs de l'état de + l'art : <emph>SSSL</emph> (Simple algorithm for Semi-supevised + Learning, <h:cite href="ji_simple_2012"/>) et celui de la + régularisation Laplacienne + <h:cite href="belkin_manifold_2006"/>. <emph>SSSL</emph> + effectue une régression simple après un changement d'espace des + données ; nous proposons de reprendre ce changement d'espace et + d'apporter une régularisation Laplacienne à la régression, pour + obtenir l'algorithme <emph>Laplacian-regularized Simple + Semi-Supervised Learning</emph>, ou <emph>LapS3L</emph>. + </p> + <p> + Nous avons proposé par la suite une adaptation + de <emph>LapS3L</emph> pour l'apprentissage multi-labels, + <emph>Laplacian-based Semi-supervised Multi-regression</emph>, + ou <emph>LSMR</emph>. L'idée principale de cette extension + consiste à imposer, au travers d'une régularisation, que les + labels similaires doivent être modélisés de manière similaire. + </p> + <p> + Nous avons également développé un algorithme de sélection de + variables multi-labels et semi-supervisé, + appelé <emph>RSMS</emph> pour <emph>Robust Semi-supervised + Multi-label feature Selection for regression</emph>. En effet, + dans le cas de l'apprentissage multi-labels, la sélection de + variables propose de sélectionner les variables utiles pour tous + les labels, simultanément. Cet algorithme de sélection de + variables introduit l'idée que la sélection de labels permet de + guider la sélection de variables. + </p> + <p> + Enfin, nous étions confrontés à un jeu de données textuel pour + la résolution d'un problème réel, qui consiste à évaluer + l'appréciation de diverses propriétés associées à des + pneumatiques dans des commentaires d'internautes. C'est la + raison pour laquelle nous avons développé un démonstrateur en + situation permettant d'adapter nos algorithmes ainsi développés + aux contingences de cette application à forte valeur ajoutée + pour l'entreprise. + </p> + <h2>Organisation du manuscrit</h2> + <p> + L'organisation de ce manuscrit suit l'ordre chronologique de nos + propositions. Dans le chapitre qui suit, nous dresserons un état + de l'art sur l'apprentissage semi-supervisé et multi-labels, en + s'intéressant également à la sélection de variables. Ensuite, + nous présenterons <emph>LapS3L</emph> + (<emph>Laplacian-regularised Simple Semi-Supervised + Learning</emph>), en décrivant les travaux utilisés, l'approche + proposée, l'algorithme d'optimisation retenu et l'étude + expérimentale mise en œuvre. Le chapitre 4 se consacrera à la + deuxième contribution, <emph>LSMR</emph> (<emph>Laplacian-based + semi-supervised multi-regression</emph>) qui est son extension + dans le cadre multi-labels. Le chapitre 5 + présentera <emph>RSMS</emph> (<emph>Robust Semi-supervised + Multi-label feature Selection for regression</emph>), pour + répondre à la problématique de la sélection de variables, dans + le cadre semi-supervisé et multi-labels. Finalement, le chapitre + 6 présentera l'application de nos travaux sur un jeu de données + réel, pour répondre à la problématique de l'entreprise sur + l'annotation automatique à partir de grandes masses de données + sur les pneumatiques. Enfin, nous conclurons ce rapport dans le + dernier chapitre avec un bilan sur les contributions proposées + et les résultats obtenus via les différentes expérimentations + menées durant cette thèse. Nous discuterons aussi quelques + propositions d'amélioration en guise de perspectives à court et + à moyen termes. + </p> + <h2>Notations</h2> + <p> + Les notations utilisées dans la suite de ce document sont + rappelées ici. + </p> + <p> + Voici les opérateurs employés : + </p> + <ul> + <li><h:eq>M'</h:eq> désigne la transposée de + lamatrice <h:eq>M</h:eq> ;</li> + <li><h:eq>\bar v</h:eq> désigne la moyenne d'un + vecteur <h:eq>v</h:eq> ;</li> + <li><h:eq>M \otimes P</h:eq> désigne le produit de Kronecker + de <h:eq>M</h:eq> par <h:eq>P</h:eq> ;</li> + <li><h:eq>M \succeq 0</h:eq> ou <h:eq>M \in S_N^{+} + (\mathbb{R})</h:eq> signifie que <h:eq>M</h:eq> est une + matrice symétrique réelle semi-définie positive.</li> + </ul> + <p> + Les notations suivantes sont employées pour la dimension du + problème d'apprentissage : + </p> + <ul> + <li><h:eq>n_l</h:eq> : le nombre d'individus labellisés de + l'ensemble d'apprentissage ;</li> + <li><h:eq>N</h:eq> : le nombre total d'individus, y compris ceux + non labellisés ;</li> + <li><h:eq>n_t</h:eq> : le nombre d'individus de test ;</li> + <li><h:eq>d</h:eq> : la dimension de l'espace des individus, ou + le nombre de variables ;</li> + <li><h:eq>m</h:eq> : le nombre de labels ;</li> + <li><h:eq>c</h:eq> : le nombre de classes pour un + classifieur ;</li> + <li><h:eq>o</h:eq> : le nombre de pseudo-labels ;</li> + <li><h:eq>s</h:eq> : le nombre de valeurs propres considérées, + par ordre croissant.</li> + </ul> + <p> + Nous utilisons ces notations pour écrire une fonction objectif : + </p> + <ul> + <li><h:eq>\alpha > 0</h:eq>, <h:eq>\beta > + 0</h:eq>, <h:eq>\gamma > 0</h:eq>, <h:eq>\delta > 0</h:eq> : + régulariseurs ;</li> + <li><h:eq>b \in \mathbb{R}^{m}</h:eq> : le vecteur de biais pour + l'apprentissage de régression ;</li> + <li><h:eq>B \in \mathbb{R}^{o, m}</h:eq> : le facteur à droite + dans la décomposition du modèle ;</li> + <li><h:eq>\Gamma</h:eq> : les coefficients du modèle SSSL ;</li> + <li><h:eq>D, D_s</h:eq> : la matrice de degré du graphe des + individus (l'indice <h:eq>s</h:eq> sert à la démarquer + de <h:eq>D_m</h:eq>) ;</li> + <li><h:eq>D_m</h:eq> : la matrice de degré du graphe des + labels ;</li> + <li><h:eq>D_W</h:eq>, <h:eq>D_B</h:eq> : matrices diagonales + pour la relaxation lisse de la norme <h:eq>l_{2, 1}</h:eq> + et <h:eq>l_{1, 2}</h:eq> ;</li> + <li><h:eq>\epsilon > 0</h:eq> : paramètre de la fonction de coût + de l'algorithme SVM (<emph>Support Vector Machine</emph>), ou + notation pour un nombre strictement positif pouvant être choisi + arbitrairement proche de 0 ;</li> + <li><h:eq>J \in \mathbb{R}^{N, N}</h:eq> : matrice diagonale + indicatrice des individus labellisés ;</li> + <li><h:eq>L \in \mathbb{R}^{N, N}</h:eq>, <h:eq>L_s</h:eq> : la + matrice Laplacienne du graphe des individus ;</li> + <li><h:eq>L_m \in \mathbb{R}^{m, m}</h:eq> : la matrice + Laplacienne du graphe des labels ;</li> + <li><h:eq>M \in \mathbb{R}^{N, N}</h:eq> : la matrice + d'adjacence du graphe des individus ;</li> + <li><h:eq>M_m \in \mathbb{R}^{m, m}</h:eq> : la matrice + d'adjacence du graphe des labels ;</li> + <li><h:eq>P, Q</h:eq> : deux matrices décomposant le + modèle <h:eq>W = P + Q</h:eq> ou <h:eq>W = P Q</h:eq> ;</li> + <li><h:eq>\mathcal{R}</h:eq> : lorsqu'une régularisation + quelconque s'applique sur un modèle <h:eq>W</h:eq>, nous la + noterons <h:eq>\mathcal{R} (W)</h:eq> ;</li> + <li><h:eq>tr</h:eq> : fonction calculant la trace d'une matrice + (la somme des valeurs de sa diagonale) ;</li> + <li><h:eq>V \in \mathbb{R}^{N, o}</h:eq> : une matrice de + pseudo-labels ;</li> + <li><h:eq>V_l \in \mathbb{R}^{n_l, o}</h:eq> : les lignes + de <h:eq>V</h:eq> correspondant aux individus labellisés ;</li> + <li><h:eq>\mathcal{V}</h:eq> : les individus du jeu + d'apprentissage pour SSSL ;</li> + <li><h:eq>\mathcal{V}_t</h:eq> : le jeu de test pour SSSL ;</li> + <li><h:eq>w \in \mathbb{R}^d</h:eq> : le modèle, sous forme de + vecteur de coefficients, pour un apprentissage mono-label ;</li> + <li><h:eq>W \in \mathbb{R}^{d, m}</h:eq> : le modèle pour un + apprentissage multi-labels ;</li> + <li><h:eq>y \in \mathbb{R}^{n_l}</h:eq> : le vecteur de labels + (pour de la régression mono-label) ;</li> + <li><h:eq>Y \in \mathbb{R}^{n, m}</h:eq> : la matrice de + labels. De dimension <h:eq>N \times m</h:eq>, elle contient des + lignes de valeur non spécifiée pour les individus non + labellisés. De dimension <h:eq>n_l \times m</h:eq>, il ne s'agit + que des individus labellisés ;</li> + <li><h:eq>\hat Y \in \mathbb{R}^{n_t, m}</h:eq> : la sortie du + modèle pour la prédiction des labels d'un ensemble + de <h:eq>n_t</h:eq> individus ;</li> + <li><h:eq>\xi</h:eq>, <h:eq>\xi^{*}</h:eq> : paramètres de marge + pour l'algorithme SVR (<emph>Support Vector + Regression</emph>) ;</li> + <li><h:eq>X \in \mathbb{R}^{N, d}</h:eq> la matrice de données + servant pour l'apprentissage ;</li> + <li><h:eq>X_l \in \mathbb{R}^{n_l, d}</h:eq> les lignes + de <h:eq>X</h:eq> correspondant aux individus labellisés.</li> + </ul> + <p> + Certains algorithmes utilisent un noyau. Les notations associées + sont : + </p> + <ul> + <li><h:eq>\mathcal{H}_{\kappa}</h:eq> : espace de Hilbert à + noyau reproduisant ;</li> + <li><h:eq>K \in \mathbb{R}^{N, N}</h:eq> : application de la + fonction de noyau à chaque paire d'individus ;</li> + <li><h:eq>K_b \in \mathbb{R}^{N, n_t}</h:eq> : application de la + fonction de noyau à chaque paire (individu d'apprentissage, + individu de test) ;</li> + <li><h:eq>\kappa \colon \mathcal{X} \times \mathcal{X} \to + \mathbb{R}</h:eq>, une fonction de noyau ;</li> + <li><h:eq>\sigma > 0</h:eq> : l'hyperparamètre de la RBF + (/Radial Basis Function/) ;</li> + <li><h:eq>U \in \mathbb{R}^{N, s}</h:eq> : les vecteurs propres + de la matrice de noyau <h:eq>K</h:eq>.</li> + </ul> + <p> + Pour décrire un algorithme, nous utilisons les notations + suivantes : + </p> + <ul> + <li><h:eq>M^{(0)}</h:eq> désigne une valeur initiale avant + itérations ;</li> + <li><h:eq>\mathbf{1}</h:eq> : un vecteur dont toutes les + composantes sont égales à 1 ;</li> + <li><h:eq>C \in \mathbb{R}^{m, o}</h:eq> : l'indicatrice des + clusters, vaut 1 si <h:eq>m</h:eq> est dans le + cluster <h:eq>o</h:eq> ;</li> + <li><h:eq>C_W</h:eq>, <h:eq>C_V</h:eq>, <h:eq>C_B</h:eq> : la + constante de Lipschitz de la fonction de gradient vis-à-vis + de <h:eq>W</h:eq>, <h:eq>V</h:eq> et <h:eq>B</h:eq> ;</li> + <li><h:eq>\mathcal{C}</h:eq> : un cluster ;</li> + <li><h:eq>f, h</h:eq> : une fonction de prédiction, prend en + entrée un individu ou un ensemble d'individus et retourne les + valeurs de tous les labels pour ces individus ;</li> + <li><h:eq>i</h:eq> : indice d'itération d'individu ;</li> + <li><h:eq>I</h:eq> : la matrice identité ;</li> + <li><h:eq>j</h:eq> : indice d'itération de variables ;</li> + <li><h:eq>k</h:eq> : indice d'itération de labels, ou nombre de + plus proches voisins ;</li> + <li><h:eq>l</h:eq> : indice d'itération de pseudo-labels ;</li> + <li><h:eq>\hat L_N</h:eq> : l'opérateur d'évaluation d'une + fonction de prédiction ;</li> + <li><h:eq>\left(\hat \lambda\right)_{i = 1}^N</h:eq> les valeurs + propres de <h:eq>\hat L_N</h:eq> ;</li> + <li><h:eq>\mathrm{min}</h:eq>, <h:eq>\mathrm{max}</h:eq> : + minimum et maximum d'un ensemble de valeurs ;</li> + <li><h:eq>\mathcal{O}</h:eq> : notation pour la complexité + temporelle ou spatiale ;</li> + <li><h:eq>p</h:eq> : indice de la norme de Minkowski ;</li> + <li><h:eq>\left(\phi\right)_{i = 1}^ N</h:eq> les fonctions + propres de <h:eq>\hat L_N</h:eq> ;</li> + <li><h:eq>\rho (M)</h:eq> désigne le rayon spectral + de <h:eq>M</h:eq>, c'est-à-dire sa plus grande valeur + propre ;</li> + <li><h:eq>\mathcal {S} \subset \{1, ..., m\}</h:eq> les labels + sélectionnés ;</li> + <li><h:eq>\sigma_i(W)</h:eq> : la <h:eq>i</h:eq><sup>ième</sup> + valeur propre de <h:eq>W</h:eq> ;</li> + <li><h:eq>x_i,\quad i = \{1 ... N\}</h:eq> : un individu de + l'ensemble d'apprentissage ;</li> + <li><h:eq>{x_l}_i,\quad i = \{1 ... n_l\}</h:eq> : un individu + labellisé de l'ensemble d'apprentissage ;</li> + <li><h:eq>z</h:eq> : le vecteur de label pour SSSL ;</li> + <li><h:eq>\hat z</h:eq> : la prédiction pour SSSL.</li> + </ul> + <p> + Enfin, <h:eq>\mathcal{X}</h:eq> désigne l’ensemble + d’apprentissage ; dans tous les cas étudiés il s’agit d’un + espace réel de dimension <h:eq>d</h:eq>. + </p> + <p> + Nous rappelons également les normes utilisées : + </p> + <ul> + <li>la norme de Minkowski, pour un + indice <h:eq>p</h:eq> : <h:eq>\left\|x\right\|_{p} = + \left(\sum_{i = 1}^n \left|x\right|^p\right)^{\frac 1 + p}</h:eq> ;</li> + <li>la norme <h:eq>l_2</h:eq>, cas particulier pour <h:eq>p = + 2</h:eq> : <h:eq>\left\|x\right\|_{2} = \sqrt{\sum_{i = 1}^n + \left|x\right|^2}</h:eq> ;</li> + <li>la norme <h:eq>l_1</h:eq>, autre cas particulier + pour <h:eq>p = 1</h:eq> : <h:eq>\left\|x\right\|_1 = \sum_{i = + 1}^n \left|x\right|</h:eq> ;</li> + <li>la norme matricielle <h:eq>l_{p, q}</h:eq> pour deux indices + de Minkowski, est la norme <h:eq>q</h:eq> du vecteur constitué + des normes <h:eq>p</h:eq> de chacune des lignes de la + matrice ;</li> + <li>la norme <h:eq>l_{2, 1}</h:eq> s'écrit + donc : <h:eq>\left\|W\right\|_{2, 1} = \sum_{j = 1} ^ d + \left\|W_{j, .}\right\|_2</h:eq> ;</li> + <li>la norme <h:eq>l_{1, 1}</h:eq> + s'écrit : <h:eq>\left\|W\right\|_{1, 1} = \sum_{j = 1} ^ d + \left\|W_{j, .}\right\|_1</h:eq> ;</li> + <li>la norme <h:eq>l_{1, 2}</h:eq> est la norme <h:eq>l_{2, + 1}</h:eq> de la transposée ;</li> + <li>la norme <h:eq>l_{\infty, 1}</h:eq> + s'écrit : <h:eq>\left\|W\right\|_{\infty, 1} = \sum_{j = 1}^d + \mathrm{max}_k |W_{j, k}|</h:eq> ;</li> + <li>la norme de Frobenius <h:eq>l_{2, 2}</h:eq> + s'écrit : <h:eq>\left\|W\right\|_F = \sqrt{\sum_{j = 1}^d + \sum_{k = 1} ^ m W_{j, k} ^ 2}</h:eq> ;</li> + <li>la norme <h:eq>l_{2, 1 - 2}</h:eq> est la différence entre + la norme <h:eq>l_{2, 1}</h:eq> et la norme de Frobenius ;</li> + <li>la norme trace s'écrit : <h:eq>\left\|W\right\|_{*} = + \sqrt{tr \left(W' W\right)} = \sum_{i = 1} ^ m \sigma_i + (W)</h:eq>, si <h:eq>\sigma_i (W)</h:eq> est + la <h:eq>i</h:eq><sup>ième</sup> valeur propre + de <h:eq>W</h:eq>.</li> + </ul> + <h1 short="État de l’art">État de l’art : Régression semi-supervisée multi-labels</h1> + <h:résumé-chapitre> + <p> + Dans ce chapitre, nous dressons un état de l'art de + l'apprentissage de régression semi-supervisée et multi-labels. + </p> + <p> + Pour l'apprentissage semi-supervisé, nous détaillons diverses + approches qui peuvent utiliser les données non + labellisées. Nous commençons par les approches de pénalisation + utilisant la régularisation Laplacienne, puis son adaptation + dans le cadre de l'algorithme SVM, ainsi que les méta-méthodes + semi-supervisées : <emph>self-training</emph> + et <emph>co-training</emph>. Nous nous intéressons également à + la sélection de variables pour l'apprentissage semi-supervisé. + </p> + <p> + Nous nous concentrons ensuite sur la régression + multi-labels. On peut également traiter le problème de + régression multi-labels grâce à des méta-méthodes, mais aussi + des régularisations spéciales conçues pour l'apprentissage + multi-labels. Nous terminons ce chapitre par un exposé de la + sélection de variables multi-labels. + </p> + </h:résumé-chapitre> + <h2>Régression semi-supervisée</h2> + <p> + Dans cette section, nous nous intéressons à la notion de + régression semi-supervisée. L'apprentissage semi-supervisé est + un sujet de recherche important. Le but est de tirer profit de + données non labellisées en plus des données labellisées, dans le + cas relativement fréquent où labelliser des données est très + coûteux, car ce processus nécessite la collaboration d'un + expert, alors que dans le même temps de grandes masses de + données non labellisées sont disponibles. + </p> + <p> + Les problèmes de régression peuvent aussi être traités dans ce + contexte d'apprentissage semi-supervisé. Ce cas dans lequel la + variable cible est continue suscite un intérêt différent du cas, + beaucoup plus fréquent, où la variable cible est discrète + (classification binaire ou multiple). Ainsi, de nombreuses + approches en apprentissage semi-supervisé sont d'abord pensées + pour une tâche de classification, ce qui parfois rend leur + adaptation plus difficile. + </p> + <h3>Apprentissage semi-supervisé</h3> + <p> + L'objectif de l'apprentissage semi-supervisé est d'exploiter les + données non labellisées, disponibles en abondance, pour + améliorer les performances en généralisation de + l'algorithme. Par exemple, prenons le cas du jeu de données + 2-lunes (<emph>two moons</emph>, figure + <h:ref href="#fig-twomoons" />). Dans ce jeu de données (en + haut), il n’y a que deux points labellisés. En ignorant les + points non labellisés, la classification donnerait le résultat + en bas à gauche, alors que le résultat en bas à droite semble + plus naturel. + </p> + <figure> + <img src="images/twomoons.svg" /> + <figcaption id="fig-twomoons"> + Le jeu de données <emph>two moons</emph> + </figcaption> + </figure> + <p> + Ce problème de classification binaire semi-supervisée est assez + inintéressant au premier abord, puisqu'il ne propose qu'un seul point + par classe. Dans ce cas, n'importe quel algorithme de classification + binaire peut obtenir une erreur résiduelle nulle en traçant une zone + de séparation entre les deux points. + </p> + <p> + Cependant, le résultat n'est pas très intuitif. On s'attendrait + à ce que chacune des deux branches du jeu de données utilise la + même étiquette de manière cohérente, en utilisant la + justification suivante : dans les zones de points à haute + densité, toutes les étiquettes devraient être les mêmes. + </p> + <p> + Si le résultat de classification est différent, on ne peut + cependant pas affirmer qu'il sera meilleur. Cependant, comme + nous le verrons plus tard, certaines connaissances a priori de + cette nature peuvent donner de meilleurs résultats + expérimentaux. + </p> + <p> + Selon <h:cite href="chapelle_semi-supervised_2006" />, il est + nécessaire de satisfaire plusieurs hypothèses pour améliorer la + performance de l'apprentissage, rappelées ici. + </p> + <p> + L'hypothèse de <emph>régularité semi-supervisée</emph> affirme + que la prédiction doit être plus lisse dans les zones à haute + densité que dans les zones à basse densité. Dans notre exemple + ci-dessus, les deux lunes sont des zones à haute densité ; la + prédiction ne doit donc pas varier rapidement dans cette + zone. En revanche, entre les deux formes lunaires se trouve une + zone à faible densité, où la prédiction peut très abruptement + basculer entre négatif et positif. + </p> + <p> + L'hypothèse de <emph>clusterisation</emph> affirme que si les + données se divisent en groupes, alors la prédiction doit être la + même sur tout le groupe. C'est principalement cette hypothèse + que nous aurions utilisée pour définir le résultat attendu de la + figure <h:ref href="#fig-twomoons" />. Ce n'est pas exactement + la même chose que l'hypothèse de régularité. En effet, elle + n'exprime rien quant à la zone de séparation, et les + regroupements ne sont pas nécessairement les zones à plus haute + densité. + </p> + <p> + Finalement, l'hypothèse de <emph>manifold</emph> affirme que les + données vivent en réalité dans un espace de plus faible + dimension. C'est en effet le cas des données de la figure : on + pourrait paramétrer cet espace par un réel unique, qui + indiquerait sur quelle lune on se trouve et à quelle position. + </p> + <p> + L'intérêt d'un algorithme de régression semi-supervisée réside + donc dans le fait qu'il soit capable de tirer avantage de ces + hypothèses, au moyen par exemple de connaissances a priori + injectées dans le modèle. Dans la suite, nous allons voir + quelques exemples d'algorithmes qui utilisent ces hypothèses. + </p> + <h4>Notations</h4> + <p> + Pour garder une certaine cohérence dans la liste des méthodes + évoquées, nous définissons ici les notations employées pour + modéliser un problème d'apprentissage semi-supervisé. + </p> + <h5>Notations générales</h5> + <p> + Le problème d'apprentissage semi-supervisé consiste à apprendre + une fonction de prédiction, <h:eq>f</h:eq>, à partir des + données. Ces données sont modélisées comme des + points <h:eq>\left(x_i\right)_{i = 1} ^ N</h:eq> dans un + espace <h:eq>\mathcal{X}</h:eq>. Dans le cas des problèmes de + régression, on considèrera uniquement que les + individus <h:eq>\left(x_i\right)_{i = 1} ^ N</h:eq> sont des + vecteurs dans un espace <h:eq>\mathbb{R}^d</h:eq>, + où <h:eq>d</h:eq> est la dimension de l'espace. La fonction de + prédiction retourne un nombre réel, dans le cadre de la + régression. On a donc : + </p> + <h:equation-x> + f \colon \mathcal{X} \to \mathbb{R} + </h:equation-x> + <p> + Parmi cet ensemble d'apprentissage semi-supervisé, on peut en + extraire un sous-ensemble supervisé constitué de paires + <h:eq>\left({x_l}_i, y_i\right)_{i = 1} ^ {n_l} \in \mathbb{R} ^ + d \times \mathbb{R}</h:eq>. En pratique, l'ensemble supervisé + constitue généralement les <h:eq>n_l</h:eq> premiers individus + de l'ensemble total. + </p> + <p> + Dans le cas linéaire, la fonction <h:eq>f</h:eq> est paramétrée + par un modèle noté <h:eq>w \in \mathbb{R} ^ d</h:eq>, et + optionnellement par un biais <h:eq>b \in \mathbb{R}</h:eq>. Le + problème d'optimisation consiste donc à trouver la valeur + de <h:eq>w</h:eq> (et <h:eq>b</h:eq>) minimisant le coût. La + fonction <h:eq>f</h:eq> s'écrit alors : + </p> + <h:equation-x> + x \mapsto \sum_{j = 1} ^ d x_j w_j + b + </h:equation-x> + <p> + Dans le cas d'un apprentissage à noyau, on définit une fonction + </p> + <h:equation-x> + \kappa \colon \mathcal{X} \times \mathcal{X} \mapsto \mathbb{R} + </h:equation-x> + <p> + qui agit sur une paire d'individus. La fonction <h:eq>f</h:eq> + dépend donc de l'ensemble + d'apprentissage <h:eq>\left(x_i\right)_{i = 1}^N</h:eq>, et elle + adopte la forme suivante : + </p> + <h:equation-x> + x \mapsto \sum_{i = 1} ^ N \kappa (x_i, x) w_i + b + </h:equation-x> + <h5>Notations matricielles</h5> + <p> + Pour la notation matricielle, on note <h:eq>X \in \mathbb{R} ^ + {N, d}</h:eq> la matrice de données, de sorte que pour tout + individu d'apprentissage <h:eq>i \in \{1, ..., + N\}</h:eq>, <h:eq>X_{i, .} = x_i</h:eq>. De la même façon, on + introduit <h:eq>X_l \in \mathbb{R} ^ {n_l, d}</h:eq> et <h:eq>y + \in \mathbb{R} ^ n_l</h:eq> pour l'ensemble labellisé des + données. Dans certains cas, les opérations sur <h:eq>y</h:eq> + sont plus communément décrites en utilisant une notation + matricielle, c'est-à-dire en considérant la + matrice-colonne <h:eq>Y \in \mathbb{R}^{n_l, 1}</h:eq> telle que + pour tout <h:eq>1 \leq i \leq n_l</h:eq>, + <h:eq>Y_{i, 1} = y_i</h:eq>. On peut reprendre cette notation + pour la valeur de la prédiction : pour un certain ensemble + d'apprentissage, comprenant <h:eq>n_t</h:eq> individus, on + obtient une matrice <h:eq>\hat Y \in \mathbb{R}^{n_t, 1}</h:eq>. + </p> + <h3>Approches de régression semi-supervisée</h3> + <p> + Nous allons présenter maintenant les approches les plus + importantes pour l'apprentissage semi-supervisé en général, et + plus particulièrement la régression semi-supervisée. En effet, + l'apprentissage semi-supervisé concentre principalement des + travaux de classification. Certains peuvent être directement + adaptés au cadre de la régression, même si d'autres utilisent + des normalisations ou des régularisations qui ne font sens que + pour un problème de classification. Enfin, certains sont + spécifiques à la régression. + </p> + <h4>Régression Laplacienne</h4> + <p> + Cette famille d'approches est très employée pour les problèmes + d'apprentissage semi-supervisé, et permet de traiter + indifféremment des problèmes de régression et des problèmes de + classification. De plus, la simplicité de l'idée qu'elle + développe lui procure une notoriété supplémentaire. + </p> + <h5>Champs gaussiens et fonctions harmoniques</h5> + <p> + L'idée développée par cette approche se résume en deux points + <h:cite href="zhu_semi-supervised_nodate" />) : + </p> + <ol> + <li> + La prédiction sur l'ensemble labellisé doit correspondre aux + valeurs de labels de l'apprentissage ; + </li> + <li> + Si deux individus sont proches (dans un sens à définir), alors + la prédiction pour ces deux individus doit être similaire. + </li> + </ol> + <p> + Tout d'abord, il faut indiquer dans quel sens deux individus + sont proches. À partir de la matrice de données <h:eq>X</h:eq>, + on construit un graphe, où chaque individu correspond à un nœud, + et dans lequel deux individus sont reliés si la distance est + suffisamment faible (ou si la similitude est suffisamment + élevée). Dans la pratique, lorsque l'on trouve une approche qui + mobilise un graphe des individus, la similarité retenue est + presque toujours donnée au travers d'un noyau gaussien, aussi + appelé <emph>radial basis function</emph> (<emph>RBF</emph>, + <h:cite href="zhu_semi-supervised_nodate" />, + <h:cite href="doquire_graph_2013" />, + <h:cite href="alalga_soft-constrained_2016" />, + <h:cite href="sousa_kernelized_nodate" />, par exemple) : si + deux individus <h:eq>i</h:eq> et <h:eq>j</h:eq> ont pour + caractéristiques <h:eq>x_i</h:eq> et <h:eq>x_j</h:eq>, la + similarité <h:eq>M_{ij} \in \mathbb{R}</h:eq> s'exprime par : + </p> + <h:equation> + M_{ij} = \mathrm{exp} \left(\frac {- \left\|x_i - + x_j\right\|_2^2} {2 \sigma ^ 2}\right) + </h:equation> + <p> + Ce qui introduit un hyperparamètre à fixer a priori, <h:eq>2 + \sigma^2 > 0</h:eq>, qui est aussi parfois + noté <h:eq>\gamma</h:eq>, ou <h:eq>4 t</h:eq> + (<h:cite href="belkin_manifold_2006" />). La + matrice <h:eq>M</h:eq> ainsi créée est souvent + appelée <h:eq>W</h:eq> pour désigner les poids du graphe. + </p> + <p> + Dans les cas où les données sont en grande dimension, par + exemple pour la classification de textes + (<h:cite href="liu_semi-supervised_2006" />), la RBF ne peut pas + s'appliquer directement, à cause de sa dépendance à la norme + <h:eq>l_2</h:eq>, qui peut difficilement distinguer des + distances entre individus en grande dimension. Par conséquent, + on peut la remplacer par la similarité cosinus : + </p> + <h:equation> + M_{ij} = \frac {\left<x_i, x_j\right>} {\left\|x_i\right\| \left\|x_j\right\|} + </h:equation> + <p> + Cette matrice <h:eq>M</h:eq> est généralement rendue + parcimonieuse (<emph>sparse</emph>), pour faciliter les calculs + quand le nombre d'individus est très élevé. En ce sens, on + affecte souvent à 0 la valeur de <h:eq>M_{ij}</h:eq> + si <h:eq>i</h:eq> et <h:eq>j</h:eq> sont trop éloignés, + c'est-à-dire si <h:eq>x_i</h:eq> n'est pas un des <h:eq>k</h:eq> + plus proches voisins de <h:eq>x_j</h:eq> et + réciproquement <h:eq>x_j</h:eq> n'est pas non plus l'un + des <h:eq>k</h:eq> plus proches voisins + de <h:eq>x_i</h:eq>. (par exemple, + <h:cite href="gunopulos_constrained_2011" /> ou + <h:cite href="zhang_semi-supervised_2009" />). + </p> + <p> + Dans tous les cas, on s'assure que la matrice <h:eq>M</h:eq> + soit symétrique. + </p> + <p> + Minimiser l'écart de prédiction entre deux individus proches + revient en fait à minimiser : + </p> + <h:equation> + \sum_{i_1 = 1}^N \sum_{i_2 = 1} ^ N M_{i_1 i_2} \left\|\hat + y_{i_1} - \hat y_{i_2}\right\|_2^2 + </h:equation> + <p> + En développant le carré, on obtient : + </p> + <h:equation> + \sum_{i_1 = 1} ^ N \sum_{i_2 = 1} ^ N M_{i_1 i_2} \hat y_{i_1} ^ + 2 + \sum_{i_1 = 1} ^ N \sum_{i_2 = 1} ^ N M_{i_1 i_2} \hat + y_{i_2} ^ 2 - 2 \sum_{i_1 = 1} ^ N \sum_{i_2 = 1} ^ N M_{i_1 + i_2} \hat y_{i_1} \hat y_{i_2} + </h:equation> + <p> + En utilisant le fait que la matrice <h:eq>M</h:eq> est + symétrique, on peut le ramener à : + </p> + <h:equation> + 2 \sum_{i = 1} ^ N \sum_{j = 1} ^ N M_{ij} \hat y_{i} ^ 2 - 2 + \sum_{i_1 = 1} ^ N \sum_{i_2 = 1} ^ N M_{i_1 i_2} \hat y_{i_1} + \hat y_{i_2} + </h:equation> + <p> + qui se simplifie en : + </p> + <h:equation> + 2 \sum_{i = 1} ^ N \left (\sum_{j = 1} ^ N M_{ij}\right) \hat + y_i ^ 2 - 2 tr\left(\hat Y' M \hat Y\right) + </h:equation> + <p> + Ceci fait apparaître la somme de chaque ligne de <h:eq>M</h:eq>, + que l'on écrit dans une matrice diagonale <h:eq>D</h:eq> (de + « degré », c'est-à-dire contenant sur la diagonale le degré de + chaque nœud du graphe) : + </p> + <h:equation-x> + D = \mathrm{diag} (M \mathbf{1}) + </h:equation-x> + <p> + Le problème revient donc à minimiser : + </p> + <h:equation> + tr\left(\hat Y' (D - M) \hat Y\right) + </h:equation> + <p> + ce qui fait apparaître tout naturellement la matrice Laplacienne + du graphe, <h:eq>L = D - M</h:eq>. En rajoutant la contrainte + concernant la prédiction sur l'ensemble labellisé, on obtient le + problème : + </p> + <h:mini id="gfhf"> + <h:variables>\hat Y \in \mathbb{R}^{n, 1}</h:variables> + <h:objective>tr \left(\hat Y' L \hat Y\right)</h:objective> + <h:add-constraint> + <h:left> + \forall 1 \leq i \leq n,\quad}{\hat Y_{i} = Y_i + </h:left> + </h:add-constraint> + </h:mini> + <p> + Ce problème d'optimisation est convexe, à condition que la + matrice <h:eq>L</h:eq> soit semi-définie positive. Il est + généralement employé pour des problèmes de classification + multi-classes (<h:cite href="sousa_kernelized_nodate" />), ce + qui demande une autre forme de normalisation pour la + matrice <h:eq>L</h:eq>, de façon à avoir des prédictions + positives et de somme 1. Pour des problèmes de régression, nous + utiliserons principalement la normalisation la plus simple + (<h:eq>L = D - M</h:eq>, <h:cite href="mifs" />). + </p> + <p> + Ce problème fait partie de la famille de problèmes + <emph>transductifs</emph>. Un problème d'apprentissage + transductif permet d'obtenir une prédiction pour les individus + non labellisés de l'ensemble d'apprentissage, cependant il est + impossible de généraliser à de nouveaux cas. + </p> + <h5>Régularisation Laplacienne LapRLS</h5> + <p> + Le problème précédent d'apprentissage transductif peut se + traduire en problème d'apprentissage inductif + semi-supervisé. Résoudre un tel problème permet d'obtenir un + modèle qui peut être utilisé pour obtenir une prédiction à + partir de n'importe quel point de la distribution des données. + </p> + <p> + L'algorithme LapRLS (<h:cite href="belkin_manifold_2006" />) + peut être interprété comme une extension de l'algorithme + précédent. Avec les notations suivantes : + </p> + <ul> + <li> + <h:eq>X \in \mathbb{R}^{N, d}</h:eq> désigne la matrice de + données ; + </li> + <li> + <h:eq>X_l \in \mathbb{R}^{n, d}</h:eq> désigne le + sous-ensemble labellisé de cette matrice ; + </li> + <li> + <h:eq>W \in \mathbb{R}^{d, 1}</h:eq> désigne le modèle ; + </li> + </ul> + <p> + la prédiction s'écrit tout simplement : + </p> + <h:equation> + f \colon X \mapsto \hat Y = X W + </h:equation> + <p> + Si l'on se concentre sur le problème de régression, on peut + réécrire l'équation <h:ref href="#gfhf" /> en : + </p> + <h:mini> + <h:variables>W \in \mathbb{R}^{d, 1}</h:variables> + <h:objective>\mathrm{tr} \left((XW)' L (XW)\right)</h:objective> + <h:add-constraint> + <h:left> + \forall 1 \leq i \leq n}{(X_l W)_{i} = Y_i + </h:left> + </h:add-constraint> + </h:mini> + <p> + Cette formulation n'est pas complète, car il n'est pas possible + de résoudre la contrainte. Cependant, on peut utiliser une + régression à la place, aux moindres carrés (<emph>Least + Squares</emph>) : en introduisant un régulariseur <h:eq>\beta > + 0</h:eq>, le problème se transforme donc en : + </p> + <h:mini id="lapls"> + <h:variables>W \in \mathbb{R}^{d, 1}</h:variables> + <h:objective> + \left\|X_l W - Y\right\|_F^2 + \beta \mathrm{tr} \left((XW)' L + (XW)\right) + </h:objective> + </h:mini> + <p> + Dans les cas où il est question d'apprentissage avec des données + à haute dimension, c'est-à-dire où <h:eq>d > N</h:eq>, la + régression aux moindres carrés ne fonctionne pas + correctement. En effet, le modèle contient trop de paramètres, + qui ne peuvent pas être déterminés par l'algorithme. Pour + pallier ce problème, on introduit généralement un terme de + régularisation supplémentaire, dit régularisation Ridge ou + Tikhonov : en introduisant un hyperparamètre supplémentaire, + <h:eq>\alpha > 0</h:eq>, on obtient : + </p> + <h:mini id="laprls"> + <h:variables>W \in \mathbb{R}^{d, 1}</h:variables> + <h:objective> + \left\|X_l W - Y\right\|_F^2 + \alpha \left\|W\right\|_F^2 + + \beta \mathrm{tr} \left((XW)' L (XW)\right) + </h:objective> + </h:mini> + <p> + Ces deux formulations (<h:ref href="#lapls" /> et + <h:ref href="#laprls" />) sont la base de nombreux algorithmes + d'apprentissage semi-supervisé. Le problème + <h:ref href="#laprls" /> peut notamment être résolu avec une + solution analytique : + </p> + <h:equation> + W = [(X_l' X_l + \alpha I + \beta X'LX]^{-1} X_l' Y + </h:equation> + <p> + Cette résolution de système linéaire nécessite un temps de + calcul en <h:eq>\mathcal{O} (N ^ 2 d ^ 3)</h:eq>, ce qui est + considérable. Pour les approches effectuant une descente de + gradient, le gradient se calcule en : + </p> + <h:equation> + \nabla_W \mathcal {L} = 2 X_l' [X_l W - Y] + 2 \alpha W + 2 + \beta X'LXW + </h:equation> + <p> + Dans les cas où la dimension <h:eq>d</h:eq> est plus grande que + le nombre d'individus <h:eq>N</h:eq>, le théorème de + représentation (<h:cite href="belkin_manifold_2006" />) nous + permet d'introduire une fonction à noyau <h:eq>\kappa \colon + \mathbb{R}^d \times \mathbb{R} ^ d \to \mathbb{R}</h:eq> et de + ne considérer comme variables que les interactions entre un + individu et le jeu d'apprentissage. On applique donc la + fonction <h:eq>\kappa</h:eq> entre tous les individus de + l'ensemble d'apprentissage (à gauche et à droite), ce qui donne + une matrice <h:eq>K \in \mathbb{R}^{N, N}</h:eq>. La solution + fait intervenir une inversion de la matrice <h:eq>K</h:eq>, ce + qui n'est pas recommandable du fait de sa dimension (<h:eq>N + \times N</h:eq>). On voit rarement cette approche appliquée dans + les travaux récents, puisque selon l'hypothèse de + l'apprentissage semi-supervisé, on dispose d'un grand nombre + d'individus non labellisés. + </p> + <h4>Algorithme LapSVM</h4> + <p> + L'algorithme SVR est une adaptation de SVM pour la régression + <h:cite href="drucker1997support" />. Le SVM a été lui-même + adapté au cadre semi-supervisé avec le <emph>SVM + transductif</emph>, d'une part, et avec une régression + Laplacienne d'autre part + (<h:cite href="chapelle_optimization_2008" />, + <h:cite href="bennett_semi-supervised_1998" />). Cependant, la + régularisation Laplacienne peut aussi s'utiliser avec les SVM en + régression (<h:cite href="chen2012laplacian" />). + </p> + <p> + Dans ce cas, on utilise la fonction de + coût <h:eq>\epsilon</h:eq>-insensible, où <h:eq>\epsilon</h:eq> + est un hyperparamètre, en combinaison de la matrice Laplacienne + d'un graphe que l'on aura calculé de la même façon qu'à la + section précédente. + </p> + <p> + On peut donc définir le problème d'apprentissage du LapSVM en + introduisant une marge supérieure <h:eq>\xi</h:eq> et une marge + inférieure <h:eq>\xi^{*}</h:eq> pour chaque point labellisé, et + en pénalisant les modèles qui donnent une prédiction hors de ces + marges. + </p> + <h:mini id="lapsvr"> + <h:variables>W \in \mathbb{R}^{d, 1}, \xi, \xi^*</h:variables> + <h:objective> + \left\|W\right\|_F^2 + \alpha \sum_{i = 1} ^ {n_l} \left(\xi_i + + \xi_i^{*}\right) + \beta \mathrm{tr} \left(W'X'LXW\right) + </h:objective> + <h:add-constraint> + <h:left>\forall 1 \leq i \leq n_l,\quad</h:left> + <h:right>X_{i}W \leq Y_{i} + \epsilon + \xi_i</h:right> + </h:add-constraint> + <h:add-constraint> + <h:left>\forall 1 \leq i \leq n_l,\quad</h:left> + <h:right>X_{i}W \geq Y_{i} - \epsilon - \xi_i^*</h:right> + </h:add-constraint> + <h:add-constraint> + <h:left>\forall 1 \leq i \leq n_l,\quad</h:left> + <h:right>\xi_i \geq 0 \land \xi_i^* \geq 0</h:right> + </h:add-constraint> + </h:mini> + <p> + On constate que la modification du SVM pour la régression + apportée pour inclure cet algorithme dans le cadre + semi-supervisé revient exactement à ajouter un terme de + régularisation Laplacienne. + </p> + <p> + Par ailleurs, une modification, nommée LapESVR + (<h:cite href="chen2012laplacian" />), introduit une nouvelle variable, + <h:eq>V</h:eq>, qui fait office <emph>d'embedding</emph> de + labels intermédiaires, d'où le nom de + l'algorithme. Concrètement, on introduit un nouvel + hyperparamètre <h:eq>\gamma</h:eq>, et on cherche à résoudre + simultanément les contraintes suivantes : + </p> + <ol> + <li> + Les valeurs du label <h:eq>Y</h:eq> sont bien reconstruites + par <h:eq>V</h:eq> sur l'ensemble labellisé ; + </li> + <li> + Si deux individus sont proches, la valeur des lignes + de <h:eq>V</h:eq> doit aussi être proche ; + </li> + <li> + Le modèle permet de bien reconstruire <h:eq>V</h:eq> avec la + fonction de coût <h:eq>\epsilon</h:eq>-insensible. + </li> + </ol> + <p> + Il s'agit donc de résoudre le problème suivant : + </p> + <h:mini id="lapesvr"> + <h:variables>W \in \mathbb{R}^{d, 1}, \xi, \xi^*, V</h:variables> + <h:objective> + \left\|W\right\|_F^2 + \alpha \sum_{i = 1} ^ n \left(\xi_i + + \xi_i^{*}\right) + \beta \mathrm{tr} \left(W'X'LXW\right) + </h:objective> + <h:break-objective> + + \gamma \mathrm{tr} \left((V - Y)'J(V - Y)\right) + </h:break-objective> + <h:add-constraint> + <h:left>\forall 1 \leq i \leq n,\quad</h:left> + <h:right>X_{i}W \leq V_{i} + \epsilon + \xi_i</h:right> + </h:add-constraint> + <h:add-constraint> + <h:left>\forall 1 \leq i \leq n,\quad</h:left> + <h:right>X_{i}W \geq V_{i} - \epsilon - \xi_i^*</h:right> + </h:add-constraint> + <h:add-constraint> + <h:left>\forall 1 \leq i \leq n,\quad</h:left> + <h:right>\xi_i \geq 0 \land \xi_i^* \geq 0</h:right> + </h:add-constraint> + </h:mini> + <p> + Avec la matrice diagonale <h:eq>J</h:eq> qui fait office + d'indicatrice des individus labellisés : + </p> + <ul> + <li> + hors de la diagonale, elle vaut 0 : <h:eq>\forall i \neq j, + J_{ij} = 0</h:eq> + </li> + <li> + sur la diagonale, elle indique les <h:eq>n</h:eq> premiers + individus : <h:eq>\forall i, J_{ii} = [i \leq n]</h:eq> + </li> + </ul> + <h4>Méta-algorithmes de régression semi-supervisée</h4> + <p> + Parmi les approches d'apprentissage semi-supervisé, on trouve + aussi des méta-méthodes qui fonctionnent à partir d'un + apprentissage supervisé. + </p> + <h5>Self-training</h5> + <p> + Le <emph>self-training</emph> est un algorithme d'apprentissage + semi-supervisé relativement simple <h:cite href="selftraining" + />. Étant donné un régresseur de base, <h:eq>h \colon + \mathcal{X} \to \mathbb{R}</h:eq>, on obtient un modèle + semi-supervisé en itérant l'algorithme suivant : + </p> + <ol> + <li> + Faire un apprentissage de <h:eq>h</h:eq> sur l'ensemble + labellisé (<h:eq>X_l</h:eq>, <h:eq>Y</h:eq>) ; + </li> + <li> + Obtenir une prédiction sur la partie non + supervisée : <h:eq>\hat Y \gets h (X)</h:eq> ; + </li> + <li id="self-pain-point"> + Sélectionner les indices des prédictions pour lesquelles la + confiance est la plus grande, <h:eq>i</h:eq>. Si la confiance + est trop faible pour tous les points non labellisés, arrêter + l'algorithme ; + </li> + <li> + Transférer <h:eq>X_{i.}, \hat Y_{i.}</h:eq> depuis l'ensemble + non labellisé vers l'ensemble labellisé. + </li> + </ol> + <p> + Cet algorithme n'est pas complètement spécifié, il reste à + définir comment l'étape <h:ref href="#self-pain-point" /> est + implémentée. Pour certains classifieurs, comme la régression + logistique <h:cite href="cramer2002origins" /> ou le SVM, il est + possible d'utiliser les scores d'appartenance à une classe. + </p> + <p> + Dans le cas d'un apprentissage pour la classification, on peut + également utiliser une méthode ensembliste pour remplacer + <h:eq>h</h:eq>. Dans ce cas, <h:eq>h</h:eq> est composé d'un + ensemble <h:eq>\left(h_i\right)_{i = 1} ^ c</h:eq> de + classifieurs, ce qui permet de définir pour un point de + l'ensemble non-labellisé <h:eq>x</h:eq> la prédiction comme + étant la classe majoritaire de l'ensemble <h:eq>\left\{h_i + (x)\right\}_{i = 1} ^ c</h:eq>. En ce qui concerne la confiance + dans la prédiction, on peut considérer l'entropie. + </p> + <p> + Dans le cas de la régression, on ne peut pas utiliser d'approche + fournissant directement un score de confiance. On peut cependant + utiliser des méthodes ensemblistes, similaires au cas de + classification <h:cite href="levatic_self_training_2017" + />. Dans ce cas, un ensemble de régresseurs est utilisé à la + place de <h:eq>h</h:eq>. Chaque régresseur donne une prédiction + pour chaque individu non labellisé. La prédiction + de <h:eq>h</h:eq> correspond à la moyenne des prédictions de + chacun des régresseurs, et la confiance est calculée à partir de + la variance des prédictions des régresseurs. Lorsque la variance + augmente, la confiance diminue. + </p> + <p> + Cette mesure de confiance est particulièrement intéressante + parce qu'il est possible d'utiliser n'importe quel régresseur + pour les <h:eq>\left(h_i\right)_i</h:eq>. Par conséquent, cette + méthode permet de construire un algorithme d'apprentissage + semi-supervisé ensembliste à partir d'un algorithme de + régression supervisée <emph>quelconque</emph>. + </p> + <p> + Les auteurs dans <h:cite href="levatic_self_training_2017" /> + définissent aussi une autre mesure de confiance, qui ne + s'applique que dans le cas d'une forêt aléatoire. Dans ce cas, + il est possible de suivre le parcours d'un individu à travers + chacun des arbres. Si deux individus aboutissent à la même + feuille pour un certain nombre d'arbres, on peut considérer + qu'ils sont voisins. Étant donné que chaque régresseur de + l'ensemble a été entraîné à partir d'un jeu d'apprentissage + différent, sélectionné par échantillonnage avec remise, pour + chaque régresseur, il existe des points de l'ensemble labellisé + qui n'ont en fait pas servi pour l'entraîner : ce sont les + exemples « hors du lot » d'apprentissage (<emph>Out of + bag</emph>). Pour évaluer la confiance d'un point de l'ensemble + d'apprentissage, on peut sélectionner les individus de + l'ensemble d'apprentissage proches, et pour chacun de ces + voisins labellisés, évaluer l'erreur de régression des + régresseurs qui n'ont pas utilisé ce point pour + l'entraînement. On obtient donc une estimation de l'erreur pour + chacun des points de l'ensemble d'apprentissage non labellisé, + qui est l'opposé de la confiance accordée à la prédiction pour + ce point. + </p> + <p> + Il est nécessaire de définir un critère d'arrêt pour + l'algorithme. En effet, si celui-ci se poursuit jusqu'à + épuisement du jeu d'apprentissage non-labellisé, il est possible + que la performance se dégrade. On choisit donc généralement un + seuil de confiance, en-dessous duquel on ne considèrera pas un + point de l'ensemble non labellisé. On peut également conserver + un ensemble de validation sur lequel évaluer chaque itération de + l'algorithme, et l'arrêter en cas de dégradation de + performance. <h:cite href="levatic_self_training_2017" /> + propose ansi de réutiliser les points <emph>out-of-bag</emph> + pour évaluer la performance de l'algorithme. + </p> + <p> + Le méta-algorithme <emph>self training</emph> peut être vu comme + étant <emph>transductif</emph>, puisque l'algorithme ne peut pas + généraliser la prédiction à un nouveau point. En effet, si un + point est ajouté dans l'ensemble non labellisé, l'ordre de + sélection peut changer à partir d'un certain point, et toutes + les prédictions et sélections suivantes seront modifiées. + </p> + <p> + En revanche, si le régresseur <h:eq>h</h:eq> (ou les + <h:eq>\left(h_i\right)_{i = 1} ^ c</h:eq>) sont inductifs, il + peut être utilisé tel quel pour effectuer une prédiction sur de + nouveaux individus. Ceci doit être considéré pour une + application d'un algorithme de <emph>self-training</emph>, mais + les études expérimentales n'ont pas besoin de s'y intéresser. + </p> + <p> + Le self-training est une méthode qui utilise les prédictions + d'un algorithme pour renforcer le jeu d'apprentissage de ce même + algorithme. En conséquence, il souffre d'un problème de biais de + confirmation <h:cite href="arazo_pseudo-labeling_nodate" />, ce + qui peut dégrader significativement les performances dans des + cas similaires. + </p> + <h5>Co-training</h5> + <p> + Le <emph>co-training</emph> <h:cite href="blum_combining_1998" + /> peut être vu comme une extension de l'algorithme de + <emph>self-training</emph>. Pour éviter de renforcer les erreurs + de l'algorithme à chaque itération, on introduit une certaine + forme de variabilité. Traditionnellement, l'ensemble des + variables est séparé en deux « vues » différentes. Par exemple, + une page web peut être décrite par le texte qui y figure, mais + aussi par les liens qui s'y trouvent. Chacune des vues est donc + un ensemble de variables. Les vues doivent être suffisantes pour + obtenir une classification des pages web, mais l'information ne + doit pas être répétée. + </p> + <p> + Une modification simple de l'algorithme de co-training peut + avoir lieu. Pour rappel, on dispose d'un classifieur de base + <h:eq>h</h:eq>. Les deux vues sont séparées en <h:eq>X_1</h:eq> + et <h:eq>X_2</h:eq> ; se rapporter à la figure + <h:ref href="#fig-multi-vues"/>. + </p> + <figure> + <img src="images/fig-multi-vues.svg" /> + <figcaption id="fig-multi-vues"> + Apprentissage semi-supervisé multi-vues pour + le <emph>co-training</emph> + </figcaption> + </figure> + <p> + Le principal consiste à : + </p> + <ol> + <li> + Faire un apprentissage d'une première instance du classifieur, + <h:eq>h_1</h:eq>, de <h:eq>{X_l}_1</h:eq> vers <h:eq>Y</h:eq> ; + </li> + <li> + Effectuer la prédiction pour l'ensemble non labellisé : + prédire <h:eq>\hat Y_1</h:eq> à partir de <h:eq>X1</h:eq> avec + le classifieur <h:eq>h_1</h:eq>, et <h:eq>\hat Y_2</h:eq> à + partir de <h:eq>X2</h:eq> avec le + classifieur <h:eq>h_2</h:eq>. Calculer également la confiance + dans la prédiction pour les deux algorithmes ; + </li> + <li> + Augmenter l'ensemble d'apprentissage du + classifieur <h:eq>h_2</h:eq> avec les prédictions les plus + confiantes de <h:eq>h_1</h:eq>, et vice versa. + </li> + </ol> + <p> + Visuellement, on peut se fier à la figure + <h:ref href="#fig-co-training" /> à titre d'exemple + illustratif. En haut à gauche, le début d’une itération montre + que certains individus sont labellisés pour les + régresseurs <h:eq>h_1</h:eq> et <h:eq>h_2</h:eq> (en blanc), et + d’autres non (en gris). En haut à droite, chaque régresseur + effectue une prédiction, et on retient celles de confiance + maximale. En bas à gauche, les valeurs prédites sont + communiquées à l’autre régresseur. En bas à droite, les nouveaux + individus sont labellisés. + </p> + <figure> + <img src="images/fig-co-training.svg" /> + <figcaption id="fig-co-training"> + Apprentissage semi-supervisé avec le <emph>co-training</emph> + </figcaption> + </figure> + <p> + En ce qui concerne l'adaptation à la régression, on trouve + principalement l'algorithme <emph>COREG</emph> + <h:cite href="zhou_semi-supervised_2005"/>, qui, au lieu + d'utiliser plusieurs vues pour entraîner deux instances + différentes de l'algorithme, utilise deux algorithmes + différents. Il s'agit de régresseurs aux plus proches voisins, + avec deux indices de Minkowski différents : <h:eq>p = 1</h:eq> + et <h:eq>p = 2</h:eq>. C'est-à-dire que les deux régresseurs + produisent une moyenne des labels des <h:eq>k</h:eq> plus + proches voisins, le premier avec la distance <h:eq>l_1</h:eq>, + le second avec la distance <h:eq>l_2</h:eq>. + </p> + <p> + Pour évaluer la certitude de la prédiction d'un des régresseurs, + l'algorithme vérifie si l'erreur de régression locale diminue en + ajoutant le point. Pour ce faire, on sélectionne <h:eq>k</h:eq> + voisins du point considéré dans l'ensemble d'apprentissage + labellisé, et on apprend une nouvelle instance du régresseur + <h:eq>h_i</h:eq>, <h:eq>h_i'</h:eq>, mais uniquement sur ce + voisinage agrémenté du point considéré. En comparant les résidus + de <h:eq>h_i</h:eq> et <h:eq>h_i'</h:eq> sur les voisins + labellisés, on peut savoir si ajouter le point augmentera ou pas + les performances locales de l'algorithme. + </p> + <p> + Il est à noter que cet algorithme fonctionne grâce au fait que + les régresseurs sont des <h:eq>k</h:eq>-NN (<h:eq>k</h:eq> plus + proches voisins). En effet, il faut effectuer un apprentissage à + chaque itération, et à chaque point non encore labellisé. + </p> + <h3> + Sélection de variables pour l'apprentissage semi-supervisé + </h3> + <p> + La sélection de variables consiste à étudier l'ensemble des + variables du jeu de données et à n'en retenir qu'un petit + nombre. Il y a plusieurs avantages à effectuer une sélection de + variables, surtout dans les applications à grande dimension (par + exemple, des applications textuelles) : + </p> + <ol> + <li> + La dimension du problème est réduite, ce qui permet + d'appliquer d'autres algorithmes ; + </li> + <li> + Le modèle est plus interprétable, c'est-à-dire que la + connaissance extraite par l'apprentissage est compréhensible + par l'être humain. + </li> + </ol> + <p> + En ce qui concerne l'apprentissage semi-supervisé, il existe + plusieurs méthodes de sélection de variables qui permettent de + tirer profit de la présence d'individus non labellisés dans le + jeu d'apprentissage. + </p> + <p> + L'évaluation de variable est une approche de sélection de + variables qui donne un score à chacune des variables. Pour en + effectuer la sélection, il suffit donc simplement de ne + conserver que les variables dont le score est le plus élevé. + </p> + <p> + Le cadre d'apprentissage semi-supervisé appelle bien souvent la + construction d'un graphe et son exploitation au travers de la + matrice Laplacienne. Pour l'évaluation des variables, on dispose + du <emph>score Laplacien</emph> + <h:cite href="he_laplacian_nodate"/>. La construction du graphe + utilise encore une fois le même procédé : les <h:eq>k</h:eq> + plus proches voisins (symétriques) sont reliés dans un graphe, + et on affecte à l'arête entre ces voisins un poids calculé à + partir de la fonction RBF. Une fois la matrice + d'adjacence <h:eq>M</h:eq> obtenue, on calcule la matrice de + degré <h:eq>D</h:eq> comme étant la diagonale de la somme des + lignes (ou des colonnes) de <h:eq>M</h:eq>, et on utilise + toujours la normalisation <h:eq>L = D - M</h:eq>. + </p> + <p> + Notons <h:eq>X^j</h:eq> la colonne <h:eq>j</h:eq> de la matrice + <h:eq>X</h:eq>. Ainsi, <h:eq>X^j</h:eq> contient les données de + la <h:eq>j</h:eq><sup>ième</sup> variable. + </p> + <p> + Une première étape consiste à normaliser chaque variable afin + d'en retirer la moyenne une fois appliquée sur le graphe : + </p> + <h:equation> + \tilde{X}^j \gets X^j - \frac {\sum_{i = 1} ^ N X_{ij} D_{ii}} + {\sum_{i = 1}^N D_{ii}} + </h:equation> + <p> + Ainsi, pour chaque variable <h:eq>X^j</h:eq>, le score Laplacien + est égal à : + </p> + <h:equation> + \frac {\left(\tilde{X}^j\right)'L\tilde{X}^j} + {\left(\tilde{X}^j\right)'D\tilde{X}^j} + </h:equation> + <p> + Cette méthode permet donc d'effectuer une sélection de variables + non supervisée. + </p> + <p> + L'utilisation du score Laplacien peut aussi être détourné pour + une sélection de variables semi-supervisée. Des travaux + (<h:cite href="barkia_semi-supervised_2011"/>, + <h:cite href="alalga_soft-constrained_2016"/>, + <h:cite href="zhao_semi-supervised_2007"/>, + <h:cite href="benabdeslem_efficient_2014"/>, + <h:cite href="hindawi_local--global_2013"/>) se sont concentrés + sur les approches en classification ; cependant on peut aussi + l'utiliser pour des applications de régression. L'algorithme + SSLS <h:cite href="doquire_graph_2013"/> se sert de la + définition du score Laplacien non-supervisé, ainsi que d'une + adaptation de ce score pour la régression supervisée, pour + fournir un score semi-supervisé. + </p> + <p> + Le score Laplacien supervisé pour la régression est très + similaire au score Laplacien non supervisé : on commence par + construire un graphe des individus, labellisés cette fois, mais + au lieu de considérer la distance entre individus selon leurs + variables, on considère la distance entre leurs labels. Ainsi, + on obtient une matrice <h:eq>M^{\mathrm{sup}}</h:eq> définie + pour une paire d'indices d'individus labellisés <h:eq>i, j \leq + n_l</h:eq> : + </p> + <h:equation> + M^{\mathrm{sup}}_{i, j} = \mathrm{exp} \left(\frac{- \left(y_i - + y_j\right)^2} {2 \sigma^2}\right) + </h:equation> + <p> + Ce graphe peut aussi être rendu <emph>sparse</emph> en ne + sélectionnant que les arêtes les plus fortes. Le score + semi-supervisé consiste donc à combiner ces deux formulations + pour obtenir le graphe suivant : + </p> + <h:equation> + M^{\mathrm{semi}}_{i, j} = + \begin{cases} + \alpha M_{i, j} ^ {\mathrm{sup}}, & i, j \leq n \\ + M_{i, j}, & i > n \vee j > n + \end{cases} + </h:equation> + <p> + avec <h:eq>M</h:eq> le score Laplacien non supervisé vu plus + haut, et <h:eq>\alpha</h:eq> un nouvel hyperparamètre qui permet + de donner plus ou moins d'importance à l'utilisation des + individus labellisés par rapport aux individus non labellisés. + </p> + <h2>Régression multi-labels</h2> + <p> + L'apprentissage multi-tâches consiste à réutiliser un modèle ou + une partie d'un modèle afin de résoudre plusieurs tâches + d'apprentissage simultanément. C'est un cadre très utilisé dans + l'apprentissage à base de données textuelles, car les + différentes tâches d'apprentissage sont reliées. Dans + <h:cite href="collobert2008unified"/>, l'apprentissage + multi-tâches s'effectue en réutilisant certaines couches du + modèle dans un réseau de neurones profond. + </p> + <p> + La régression multi-labels est un cas particulier de la + régression multi-tâches. Dans le cadre de la régression + multi-labels, toutes les tâches sont continues et à une + dimension. La prédiction pour un individu consiste en exactement + une valeur pour chacun des labels. Cette distinction peut être + comprise en comparant un jeu de données multi-tâches très + utilisé, <emph>schools</emph> + <h:cite href="argyriou2008spectral"/>, et un jeu de données + multi-labels, <emph>sarcos</emph> <h:cite href="sarcos"/>. + </p> + <p> + Le jeu de données <emph>schools</emph> est une agrégation des + résultats d'élèves différents dans des écoles différentes ; pour + chaque école, la variable cible est la note de l'élève, et les + variables consistent en des constantes par école et des + variables descriptives de l'élève. Tous les élèves sont décrits + dans le même espace de variables, on peut donc considérer le + problème comme multi-tâches. Cependant, chaque élève n'est + inscrit que dans une seule école, il est donc impossible de + considérer ce jeu de données comme multi-tâches. + </p> + <p> + En comparaison, <emph>sarcos</emph> est tiré d'un robot, dont on + a mesuré les positions, vitesses et accélérations des + articulations, et dont on cherche à prédire les moments aux + articulations. Cette fois-ci, il s'agit d'un jeu de données + multi-labels puisque chaque mesure donne une valeur pour tous + les labels. + </p> + <p> + L'apprentissage multi-labels a concerné historiquement des + problèmes de classification binaire, il faut donc faire + attention à ne pas le confondre avec la classification + multi-classes. Dans l'apprentissage multi-labels, on suppose que + les labels partagent de l'information. On peut notamment + s'intéresser à la corrélation entre labels. + </p> + <h3>Métriques de régression multi-labels</h3> + <p> + Il y a différentes façons d'évaluer un algorithme de régression + multi-labels. On cherche en effet à comparer les résultats de la + prédiction, <h:eq>\hat Y \in \mathbb{R}^{d, m}</h:eq>, avec les + vraies valeurs, <h:eq>Y \in \mathbb{R}^{d, m}</h:eq>. + </p> + <p> + On note : + </p> + <ul> + <li> + la moyenne du label <h:eq>1 \leq k \leq m</h:eq> : <h:eq>\bar + Y_k</h:eq> ; + </li> + <li> + la matrice moyenne, <h:eq>\bar Y \in \mathbb{R}^{n_t, + m}</h:eq>, définie par : <h:eq>\bar Y_{i, k} = \left[\bar + Y_k\right]_{i, k}</h:eq>. + </li> + </ul> + <p> + Les métriques usuelles de régression mono-label peuvent être + réutilisées pour définir des métriques multi-labels. Pour + rappel, on trouve : + </p> + <ul> + <li> + la <emph>RMSE</emph>, pour <emph>root of mean of squared + error</emph>, i.e. la racine de l'erreur quadratique moyenne ; + </li> + <li> + la <emph>MAE</emph>, pour <emph>mean absolute error</emph>, + i.e. erreur absolue moyenne ; + </li> + <li> + les métriques relatives : <emph>RRSE</emph> pour <emph>root of + relative squared error</emph>, i.e. racine de l'erreur + quadratique relative, et <emph>rae</emph> pour <emph>root of + absolute error</emph>, i.e. racine de l'erreur absolue. Ces + métriques expriment le rapport entre la métrique associée à + la prédiction et la métrique associée à la prédiction + constante de la moyenne du label ; + </li> + <li> + le coefficient de corrélation <emph>CC</emph> entre <h:eq>\hat + Y_{.1}</h:eq> et <h:eq>Y_{.1}</h:eq>. + </li> + </ul> + <p> + L'extension de ces métriques en multi-labels consiste à définir + une métrique <emph>moyenne</emph> ou <emph>macro</emph>, et une + métrique <emph>micro</emph>. La métrique moyenne, préfixée par + un « a » pour <emph>average</emph>, consiste à calculer la + métrique sur tous les labels et à en retenir la moyenne. La + métrique micro, préfixée par un « µ », consiste à mettre bout à + bout les labels pour appliquer la métrique mono-label. + </p> + <p> + En ce qui concerne la métrique <emph>MAE</emph>, il n'y a pas de + différence, puisqu'on peut intervertir l'ordre des + sommations. On ne conservera donc que la <emph>aMAE</emph>. + </p> + <h:equation> + \begin{aligned} + \mathbf{\mathrm{aRMSE}} &= \frac 1 m \sum_{k = 1} ^ m \sqrt{\frac 1 n_t \sum_{i = 1} ^ {n_t} \left(\hat Y_{i, k} - Y_{i, k}\right) ^ 2} & + \mathrm{\mu{}RMSE} &= \sqrt{\frac 1 {n_t m} \sum_{i, k = 1} ^ {n_t, m} \left(\hat Y_{i, k} - Y_{i, k}\right) ^ 2} \\ + \mathrm{aMAE} &= \frac 1 {n_t m} \sum_{i, k = 1} ^ {n_t, m} \left|\hat Y_{i, k} - Y_{i, k}\right| &\quad&\quad \\ + \mathrm{aRRSE} &= \frac 1 m \sum_{k = 1} ^ m \sqrt {\frac {\sum_{i = 1} ^ {n_t} \left(\hat Y_{i, k} - Y_{i, k}\right) ^ 2} {\sum_{i = 1} ^ {n_t} \left(\bar Y_{k} - Y_{i, k}\right) ^ 2}} & + \mathrm{\mu{}RRSE} &= \sqrt {\frac {\sum_{i, k = 1} ^ {n_t, m} \left(\hat Y_{i, k} - Y_{i, k}\right)^2} {\sum_{i, k = 1} ^ {n_t, m} \left(\bar Y_{k} - Y_{i, k}\right)^2}} \\ + \mathrm{aRAE} &= \frac 1 m \sum_{k = 1} ^ m \frac {\sum_{i = 1} ^ {n_t} \left|\hat Y_{i, k} - Y_{i, k}\right|} {\sum_{i = 1} ^ {n_t} \left|\bar Y_{k} - Y_{i, k}\right|} & + \mathrm{\mu{}RAE} &= \frac {\sum_{i, k = 1} ^ {n_t, m} \left| \hat Y_{i, k} - Y_{i, k}\right|} {\sum_{i, k = 1} ^ {n_t, m} \left| \bar Y_{k} - Y_{i, k}\right|} \\ + \mathrm{aCC} &= \frac 1 m \sum_{k = 1} ^ m \frac {\sum_{i = 1} ^ {n_t} \left(\hat Y_{i, k} - \bar {\hat Y}_{k}\right) \left(Y_{i, k} - \bar Y_{k}\right)} {\left\|\hat Y_{., k} - \bar {hat Y}_{k}\right\| \left\|Y_{., k} - \bar Y_{k}\right\|} & + \mathrm{\mu{}CC} &= \frac {\mathrm{tr} \left(\left(\hat Y - \bar {\hat Y}\right)'\left(Y - \bar Y\right)\right)} {\left\|\hat Y - \bar {\hat Y}\right\|_F \left\|Y - \bar Y\right\|_F} + \end{aligned} + </h:equation> + <p> + Parmi toutes ces métriques, la <emph>aRMSE</emph> est la plus + employée. + </p> + <h3>Chaînes de régresseurs pour l'apprentissage multi-labels</h3> + <p> + Nous allons commencer par étudier les approches algorithmiques + qui permettent de convertir un régresseur mono-label en + régresseur multi-labels + <h:cite href="spyromitros_xioufis_multi_target_2016"/>. + </p> + <h4><emph>Stacking</emph> pour la régression multi-labels</h4> + <p> + Pour réutiliser l'information des labels, l'approche de + transformation la plus populaire est l'empilement de régresseurs + (<emph>stacking</emph>). Dans ce contexte, un régresseur est + entraîné pour chaque label. On obtient un nouvel espace de + description des individus, en combinant les variables du jeu + d'apprentissage et les valeurs des labels. Un deuxième ensemble + de régresseurs est entraîné, ce qui permet d'effectuer une + prédiction en deux temps tout en conservant de l'information + entre tous les labels. + </p> + <h4>Chaînes de régresseurs</h4> + <p> + Il est possible de développer cette approche. Pour construire + une chaîne de régresseurs, il faut sélectionner un ordre des + labels, puis pour chacun, entraîner un régresseur pour obtenir + une prédiction pour ce label à partir de l'ensemble des + variables ainsi que l'ensemble des prédictions pour les labels + précédemment sélectionnés. La prédiction se fait dans le même + ordre, en utilisant les prédictions précédentes. On obtient + l'algorithme <emph>RCC</emph> pour chaîne de régresseurs + corrigée (<emph>regressor chains corrected</emph>, la correction + venant du fait que chaque étape effectue une prédiction à partir + des prédictions et non des labels). + </p> + <h4>Chaînes de régresseurs ensemblistes</h4> + <p> + Cette méthode ne donne pas le même résultat selon l'ordre de + sélection des labels. C'est un problème, car la prédiction pour + le premier label ne peut pas s'appuyer sur la prédiction des + autres : il est de fait traité comme un problème mono-label. Ce + problème est résolu en prenant plusieurs ordres différents, et + en effectuant une prédiction ensembliste, où la valeur prédite + pour chaque label est la moyenne des valeurs prédites par chaque + ordre de sélection. + </p> + <h3>Approches portant sur la régularisation multi-labels</h3> + <p> + En ce qui concerne les approches de régression, l'optimisation + de méthodes de régularisation multi-labels pose un problème + supplémentaire par rapport à la régression mono-label. En effet, + si l'on veut appliquer une simple régularisation Ridge en + multi-labels, la solution est simple à calculer : + </p> + <h:equation> + W = [X' X + \alpha I] ^ {-1} X' Y + </h:equation> + <p> + Malheureusement, en ajoutant des régularisations relatives aux + labels, par exemple en remplaçant le terme Ridge + par <h:eq>\alpha \left\|WA\right\|</h:eq> avec <h:eq>A</h:eq> + une matrice quelconque, on obtient : + </p> + <h:equation> + \left[[X' X] \otimes I_m + \alpha I_d \otimes [A A']\right] ^{-1} X' Y + </h:equation> + <p> + où <h:eq>I_m</h:eq> (<h:eq>I_d</h:eq>) est la matrice identité + de dimension <h:eq>m</h:eq> (<h:eq>d</h:eq>) et <h:eq>\_ \otimes + \_</h:eq> désigne le produit de Kronecker. La dimension du + système à résoudre n'est donc plus <h:eq>d \times d</h:eq>, mais + bien <h:eq>d \times d \times m \times m</h:eq>, et on ne peut + plus se satisfaire de solution analytique au problème. + </p> + <h4>MALSAR (Multi task Learning via structural regularization)</h4> + <p> + MALSAR <h:fn><a href="https://github.com/jiayuzhou/MALSAR">https://github.com/jiayuzhou/MALSAR</a></h:fn> + est une implémentation d'un ensemble de méthodes partageant + l'utilisation d'une fonction objectif régularisée pour traiter + le problème multi-labels. L'optimisation se fait toujours par + descente de gradient accélérée, ce qui résout le problème de + complexité soulevé plus haut. + </p> + <h4>Lasso par groupe</h4> + <p> + La régularisation du Lasso par groupe, <emph>group lasso</emph> + <h:cite href="argyriou_multitask_nodate"/>, utilise l'hypothèse + suivante : + </p> + <blockquote> + Parmi l'ensemble des variables du problème, seul un certain + nombre d'entre elles sont utiles pour la prédiction simultanée + de tous les labels. + </blockquote> + <p> + Pour utiliser cette hypothèse, le Lasso + <h:cite href="tibshirani1996regression"/>, ou + régularisation <h:eq>l_1</h:eq>, est un bon candidat. En effet, + si l'on considère le problème suivant : + </p> + <h:mini> + <h:variables>w \in \mathbb{R}^{d}</h:variables> + <h:objective> + \left\|Xw - y\right\|_2^2 + \alpha \left\|w\right\|_1 + </h:objective> + </h:mini> + <p> + La solution, en fonction de la valeur de <h:eq>\alpha</h:eq>, + sera plus ou moins <emph>sparse</emph>, c'est-à-dire que le + modèle <h:eq>w</h:eq> aura un certain nombre de composantes + entièrement nulles. Plus précisément, l'optimisation de ce + problème par descente de gradient proximal nous indique que la + solution se situe à une distance <h:eq>l_1</h:eq> de + <h:eq>\alpha^{-1}</h:eq> de l'origine. Si le problème a deux + dimensions, une grande valeur de <h:eq>\alpha</h:eq> laisse une + plus grande partie de l'espace menant à une solution où l'une + des coordonnées du modèle est nulle, cf figure + <h:ref href="#fig-lasso"/>. + </p> + <figure> + <img src="images/lasso.svg" /> + <figcaption id="fig-lasso"> + Comparaison de modèles pour Lasso : lorsque le régulariseur + <h:eq>\alpha</h:eq> est grand, les zones dans lesquelles le + modèle perd une composante sont plus étendues. + </figcaption> + </figure> + <p> + Pour l'apprentissage multi-labels, l'extension du lasso retenue + est le lasso par groupe + <h:cite href="argyriou_multitask_nodate"/>. En effet, on suppose + que tous les labels peuvent être prédits à partir d'un + sous-ensemble des variables. On souhaite donc appliquer une + régularisation équivalente, en n'appliquant la régularisation + que sur les <emph>lignes</emph> de <h:eq>W</h:eq>. On obtient + donc le problème <h:ref href="#mtfl"/> : + </p> + <h:mini id="mtfl"> + <h:variables>W \in \mathbb{R}^{d, m}</h:variables> + <h:objective> + \left\|XW - Y\right\|_F^2 + \alpha \sum_{j = 1} ^ d \left\|W_{j.}\right\|_2 + </h:objective> + </h:mini> + <p> + La norme ainsi obtenue est notée <h:eq>\left\|W\right\|_{2, + 1}</h:eq>. + </p> + <p> + Cette formulation utilise la norme <h:eq>l_{2,1}</h:eq>. Il est + possible d'utiliser d'autres normes pour obtenir un résultat + comparable. L'algorithme nommé <emph>Dirty Model</emph> + <h:cite href="jalali_dirty_nodate"/> utilise deux termes pour la + régularisation, afin de pouvoir traiter à la fois les cas où + l'on peut réutiliser les mêmes variables pour tous les labels, + et ceux où il faut un modèle différent par label. Le modèle + s'exprime de la façon suivante <h:ref href="#dirty"/> : + </p> + <h:mini id="dirty"> + <h:variables>W = P + Q, P \in \mathbb{R} ^ {d, m}, Q \in \mathbb{R} ^ {d, m}</h:variables> + <h:objective> + \left\|X (P + Q) - Y\right\|_F^2 + \alpha \left\|P\right\|_{1, 1} + \beta \left\|Q\right\|_{\infty, 1} + </h:objective> + </h:mini> + <p> + Pour plus de clarté, on utilise la notation + <h:eq>\left\|Q\right\|_{\infty, 1}</h:eq> et pas la notation + employée dans l'article original + <h:cite href="jalali_dirty_nodate"/>. + </p> + <p> + En sélectionnant les hyperparamètres <h:eq>\alpha</h:eq> + et <h:eq>\beta</h:eq>, il est possible de traiter mieux plus de + cas que le problème <h:ref href="#mtfl"/>. Le modèle se + décompose donc en deux termes, comme le montre la figure + <h:ref href="#fig-dirty"/>. + </p> + <figure> + <img src="images/dirty.svg" /> + <figcaption id="fig-dirty"> + Un régresseur produit par le <emph>dirty model</emph> + </figcaption> + </figure> + <h4>Régularisation Laplacienne multi-labels</h4> + <p> + La régularisation Laplacienne évoquée tout au long de ce + document peut également être utilisée pour une régularisation + multi-labels <h:cite href="malsar"/>. En effet, si l'on + considère que chaque label correspond à un nœud d'un graphe, on + peut définir une arête entre deux labels comme la similarité + entre ces deux labels. Pour cela, si l'on considère deux labels + quelconques, on peut comparer pour chaque individu les valeurs + assignées à ces deux labels. On peut ensuite agréger le résultat + sur tous les individus. Concrètement, la construction du graphe + se fait en utilisant non pas <h:eq>X</h:eq> comme pour + l'utilisation semi-supervisée, + mais <h:eq>Y_l'</h:eq>. L'hypothèse que l'on souhaite mettre en + œuvre peut être résumée de la façon suivante : + </p> + <blockquote> + Si deux labels sont similaires, les valeurs du modèle pour ces + deux labels doivent être similaires. + </blockquote> + <p> + On peut donc utiliser la fonction objectif suivante : + </p> + <h:mini id="srmtl"> + <h:variables>W \in \mathbb{R}^{d, m}</h:variables> + <h:objective> + \left\|X W - Y\right\|_F^2 + \alpha \mathrm{tr} (W L_m W') + </h:objective> + </h:mini> + <p> + Cette régularisation est utilisée dans l'algorithme GLOCAL + <h:cite href="zhu_multilabel_2017"/>, qui part du principe que + les données peuvent être partitionnées en sous-ensembles dans + lesquels la corrélation entre labels est différente. + </p> + <h4>Régularisation sur le rang</h4> + <p> + L'hypothèse selon laquelle les labels partagent de l'information + peut aussi se traduire par une contrainte sur le rang (des + colonnes) du modèle <h:eq>W</h:eq>. En effet, si l'on considère + que le modèle <h:eq>W</h:eq> s'écrit comme un produit <h:eq>P + \times Q</h:eq>, avec deux matrices <h:eq>P \in \mathbb{R}^{d, + o}</h:eq> et <h:eq>Q \in \mathbb{R}^{o, m}</h:eq>, alors le + modèle est de rang au plus <h:eq>o</h:eq>, et on peut constater + que l'information contenue dans <h:eq>P</h:eq> est réutilisée + pour tous les labels. + </p> + <p> + Dans la pratique, cette idée se traduit par une régularisation + sur la norme trace de la matrice <h:eq>W</h:eq> + <h:cite href="rank"/>. + </p> + <h:equation> + \left\|W\right\|_{*} = \sqrt{tr \left(W' W\right)} = \sum_{i = 1} ^ m \sigma_i (W) + </h:equation> + <p> + où <h:eq>\left(\sigma_i (W)\right)_{i = 1} ^ m</h:eq> désigne + l'ensemble des valeurs propres de la + matrice <h:eq>W</h:eq>. Dans ce cas, le problème s'écrit : + </p> + <h:mini> + <h:variables>W \in \mathbb{R}^{d, m}</h:variables> + <h:objective> + \left\|XW - Y\right\|_F^2 + \alpha \left\|W\right\|_{*} + </h:objective> + </h:mini> + <h4>Classification des labels</h4> + <p> + L'approche <emph>CMTL</emph> pour <emph>clustered multi-task + learning</emph> propose de faire une classification des labels, + à partir de l'algorithme des <h:eq>k</h:eq>-moyennes. Selon + <h:cite href="zha_spectral_nodate"/>, si l'on a <h:eq>o</h:eq> + clusters de labels, en supposant que les clusters sont + <h:eq>\left(\mathcal{C}_{l}\right)_{l = 1}^o</h:eq>, dont chacun + est de taille <h:eq>n_l</h:eq>, et l'indicatrice des clusters se + nomme <h:eq>C \in \mathbb{R}^{k, m}</h:eq> telle que : + </p> + <h:equation> + C_{k l} = + \begin{cases} + \frac 1 {\sqrt{n_l}}, & k \in \mathbb{\mathcal{C}_l} \\ + 0, & k \notin \mathbb{\mathcal{C}_l} + \end{cases} + </h:equation> + <p> + on peut écrire le coût de la façon suivante : + </p> + <h:equation> + \sum_{l = 1}^o \sum_{k \in \mathcal{C}_{l}} \left\|W_{.k} - \frac 1 {n_l} \sum_{k' \in \mathcal{C}_l} W_{.k}\right\|_2^2 \\ += \mathrm{tr} \left(W' W\right) - \mathrm{tr} \left(C'W'WC\right) + </h:equation> + <p> + En relaxant la définition de <h:eq>C</h:eq> pour avoir + simplement <h:eq>C' C = I</h:eq>, le problème + des <h:eq>k</h:eq>-moyennes devient : + </p> + <h:mini> + <h:variables>C \in \mathbb{R}^{m, o}</h:variables> + <h:objective> + \mathrm{tr} \left(W'W\right) - \mathrm{tr} \left(C'W'WC\right) + </h:objective> + <h:add-constraint> + <h:left> + C'C = I + </h:left> + </h:add-constraint> + </h:mini> + <p> + À partir de cette formulation, il est possible de construire une + fonction objectif multi-labels <h:cite href="cmtl"/> : + </p> + <h:mini> + <h:variables>W \in \mathbb{R}^{d, m}, C \in \mathbb{R}^{m, o}</h:variables> + <h:objective> + \left\|XW - Y\right\|_F^2 + \alpha \left(\mathrm{tr} \left(W'W\right) - \mathrm{tr} \left(C'W'WC\right)\right) + \beta \left\|W\right\|_F^2 + </h:objective> + <h:add-constraint> + <h:left> + C'C = I + </h:left> + </h:add-constraint> + </h:mini> + <p> + La formulation n'étant pas convexe, elle n'est pas + satisfaisante. <h:cite href="cmtl"/> propose donc de + poser <h:eq>M = CC'</h:eq>, <h:eq>\eta = \frac \beta + \alpha</h:eq>, pour obtenir la fonction objectif suivante : + </p> + <h:mini> + <h:variables>W \in \mathbb{R}^{d, m}, M \in \mathbb{R}^{m, m}</h:variables> + <h:objective> + \left\|XW - Y\right\|_F^2 + \alpha \eta \left(1 + \eta\right) \mathrm{tr} \left(W \left(\eta I + M \right)^{-1}W'\right) + </h:objective> + <h:add-constraint><h:left>M \succeq 0</h:left></h:add-constraint> + <h:add-constraint><h:left>I - M \succeq 0</h:left></h:add-constraint> + <h:add-constraint><h:left>\mathrm{tr} \left(M\right) = o</h:left></h:add-constraint> + </h:mini> + <p> + La notation <h:eq>M \succeq 0</h:eq> signifie que <h:eq>M</h:eq> + est une matrice réelle symétrique semi-définie positive. + </p> + <h4>Régularisation non-convexe avec une norme plafonnée</h4> + <p> + Jusqu'à présent, toutes les fonctions objectifs que nous avons + décrites sont convexes, ou convexes selon chacune de leurs + variables. Cependant, on peut également envisager des + régularisations non convexes. On n'obtient en général pas de + garantie de convergence, mais les résultats expérimentaux sont + souvent suffisamment importants pour qu'il ne soit pas possible + d’ignorer ces approches. + </p> + <p> + La norme <h:eq>l_1</h:eq> plafonnée + <h:cite href="cappedl1,msmtfl"/> consiste simplement à + régulariser certaines <emph>lignes</emph> du + modèle <h:eq>W</h:eq> avec la norme <h:eq>l_1</h:eq>, mais pas + toutes. Les lignes ayant des valeurs importantes ne sont pas + régularisées. Ce n'est pas la même chose que la + norme <h:eq>l_{2, 1}</h:eq> vue précédemment : ici, + l'application de la norme pour une variable régularisée signifie + qu'il n'y aura que quelques labels utilisant cette variable. + </p> + <p> + Le problème s'écrit de la façon suivante : + </p> + <h:mini> + <h:variables>W \in \mathbb{R}^{d, m}</h:variables> + <h:objective> + \left\|XW - Y\right\|_F^2 + \alpha \sum_{j = 1} ^ d \mathrm{min} \left(\left\|W_{j.}\right\|_1, \beta\right) + </h:objective> + </h:mini> + <p> + Ce problème n'est pas convexe ; il peut cependant être relaxé + pour être résolu itérativement, en utilisant plusieurs étapes + (d'où son nom). À chaque itération, on détermine les lignes pour + lesquelles la régularisation s'applique, en calculant la norme + <h:eq>l_1</h:eq> du modèle à l'itération précédente. Puis on + résout le problème en appliquant la régularisation uniquement + sur ces lignes. + </p> + <p> + La relaxation converge vers la solution du problème non convexe, + sous certaines conditions <h:cite href="msmtfl"/>. + </p> + <p> + En ce qui concerne la régularisation sur le rang, il est aussi + possible de traiter un problème de norme plafonnée + <h:cite href="msmtflrank"/>. Le problème s'écrit alors : + </p> + <h:mini> + <h:variables>W \in \mathbb{R}^{d, m}</h:variables> + <h:objective> + \left\|XW - Y\right\|_F^2 + \alpha \sum_{k = 1}^m \mathrm{min} \left(\sigma_k\left(W\right), \beta\right) + </h:objective> + </h:mini> + <p> + La notation <h:eq>\sigma_k (W)</h:eq> désigne + la <h:eq>k</h:eq><sup>ième</sup> valeur propre + de <h:eq>W</h:eq>. Si l'on suit le même processus de relaxation + que pour MSMTFL <h:cite href="msmtfl"/>, la régularisation ne + doit s'appliquer que sur les plus petites valeurs propres. Si + l'on note <h:eq>s</h:eq> le nombre de valeurs propres + supérieures à <h:eq>\beta</h:eq>, + et <h:eq>\left\|W\right\|_{s^{-}}</h:eq> la somme des valeurs + propres de <h:eq>W</h:eq>, sauf les <h:eq>s</h:eq> premières, + chaque itération résout le problème suivant : + </p> + <h:mini> + <h:variables>W \in \mathbb{R}^{d, m}</h:variables> + <h:objective> + \left\|XW - Y\right\|_F^2 + \alpha \left\|W\right\|_{s^{-}} + </h:objective> + </h:mini> + <p> + Cette norme peut en fait se réécrire comme la norme trace, moins + un terme calculé à partir de la décomposition en valeurs propres + du modèle à l'itération précédente, en tronquant la + décomposition à <h:eq>s</h:eq> termes. C'est un problème + convexe, mais avec un terme non lisse (la norme trace), qui peut + être résolu de la même manière que la régularisation trace + seule. + </p> + <h3>Semi-Supervised Multi-Task Regression, avec contraintes</h3> + <p> + L'algorithme <emph>SSMTR</emph> + <h:cite href="zhang_semi-supervised_2009"/> est une approche non + linéaire, utilisant un noyau, permettant de traiter le problème + de régression semi-supervisée en multi-labels. Il s'agit d'une + extension de la régression multi-labels + semi-supervisée <emph>SMTR</emph>, présentée également + dans <h:cite href="zhang_semi-supervised_2009"/>. + </p> + <p> + Dans <emph>SMTR</emph>, chaque label est traité séparément par + un apprentissage à noyau, mais les paramètres des noyaux pour + tous les labels sont issus de la même distribution. C'est une + façon de réutiliser de l'information entre labels. L'extension + au cadre semi-supervisé vise à définir pour chaque label un + graphe d'individus, en déduire la matrice Laplacienne et + l'utiliser en complément du noyau multi-labels. + </p> + <p> + Bien qu'une matrice Laplacienne soit calculée pour chaque label, + l'inférence du modèle évite de calculer un produit de + Kronecker. En revanche, cette extension correspond bien à la + régression Laplacienne mono-label classique : une fois le jeu de + données non labellisé utilisé pour apprendre le modèle, il est + éliminé et ne sert plus pour la + prédiction. <h:cite href="zhang_semi-supervised_2009"/> propose + donc d'ajouter deux types de contraintes : + </p> + <ol> + <li> + La prédiction pour un individu est supérieure à la prédiction + pour un autre individu (avec une marge) ; + </li> + <li> + Un écart de prédiction entre deux individus doit être + supérieur à un écart de prédiction entre deux autres + individus. + </li> + </ol> + <p> + L'inférence devient plus délicate, mais donne de meilleurs + résultats pour les jeux de données évoqués + précédemment <emph>sarcos</emph> et <emph>schools</emph>. + </p> + <h3>Le problème de sélection de variables multi-labels</h3> + <p> + Dans un problème d'apprentissage multi-labels, la sélection de + variables a un sens légèrement plus précis : on doit trouver un + sous-ensemble des variables qui permet d'obtenir une bonne + prédiction pour <emph>tous</emph> les labels + simultanément. Ainsi, on peut difficilement généraliser les + approches de sélection de variables mono-label directement au + multi-labels. Par exemple, l'utilisation du score Laplacien + supervisé, utilisé dans <emph>SSLS</emph> + <h:cite href="doquire_graph_2013"/> permet de faire de la + sélection de variables pour plusieurs labels, mais ne correspond + pas vraiment au problème de sélection de variables + multi-labels. En effet, la construction du graphe supervisé met + en relation les individus de l'ensemble d'apprentissage dont la + distance dans l'espace des labels est faible. La sélection de + variables consiste donc en une sélection <emph>moyenne</emph> + pour les différents labels, et elle n'est pas conçue pour + traiter tous les labels en même temps. + </p> + <p> + De la même façon, une adaptation naïve du Lasso en multi-labels + ne permet pas de résoudre le problème de sélection de variables + multi-labels. En effet, si l'on cherche à résoudre le problème + suivant : + </p> + <h:mini id="mtl"> + <h:variables>W \in \mathbb{R}^{d, m}</h:variables> + <h:objective> + \left\|X W - Y\right\|_F^2 + \alpha \sum_{j = 1} ^ d \sum_{k = 1} ^ m \left|W_{jk}\right| + </h:objective> + </h:mini> + <p> + On obtiendra une matrice <h:eq>W</h:eq> sparse, mais ce n'est + pas suffisant : il se peut que chaque label demande un + sous-ensemble différent de variables. Il faut que tous les + labels partagent un même sous-ensemble de variables. + </p> + <h4>Utilisation du Lasso par groupe</h4> + <p> + Pour pallier ce problème, il faut utiliser une version un peu + moins naïve du Lasso. En construisant un modèle + linéaire <h:eq>W</h:eq>, les lignes correspondent aux + coefficients pour une variable et les colonnes correspondent aux + coefficients pour un label. Ainsi, si l'on veut pouvoir exprimer + tous les labels avec un petit nombre de variables, il faut que + la matrice <h:eq>W</h:eq> ait un petit nombre de lignes non + nulles. Il faut donc appliquer une régularisation de type Lasso + sur les lignes de <h:eq>W</h:eq>, c'est-à-dire un lasso par + groupe. On retrouve donc directement + l'algorithme <emph>JFS</emph> + <h:cite href="argyriou_multitask_nodate"/>. + </p> + <h4> + Régularisation <h:eq>l_{2,1 - 2}</h:eq> non convexe pour la + sélection de variables + </h4> + <p> + Si l'on examine la norme <h:eq>l_{2,1}</h:eq> pour un modèle à 2 + variables et 1 label, on obtient la figure + <h:ref href="#fig-l21"/> haut. On constate que la valeur de la + fonction de coût est plus faible si l'une des coordonnées du + modèle est nulle, et elle est globalement minimale si les deux + coordonnées sont nulles. C'est utile pour la sélection de + variables, puisque l'optimisation du problème pourra éliminer + l'une des deux variables. Cependant, <h:cite href="l21m2"/> + propose une amélioration pour la sélection de variables + multi-labels, en utilisant la différence entre la + norme <h:eq>l_{2, 1}</h:eq> et la norme <h:eq>l_2</h:eq>. Les + effets de cette régularisation sont très parlants pour un modèle + à 2 variables (figure <h:ref href="#fig-l21"/> bas) : le coût + est exactement nul dès que l'une des variables est éliminée. + </p> + <figure> + <img src="images/l21m2.svg" /> + <figcaption id="fig-l21"> + Norme <h:eq>l_{2, 1}</h:eq> et <h:eq>l_{2, 1 - 2}</h:eq> d’un + modèle à 2 variables et 1 label. + </figcaption> + </figure> + <p> + Ce problème n'est pas convexe, cependant il est possible de + l'optimiser en relaxant la partie non convexe par le plan + tangent à chaque itération. + </p> + <h4>Multi-Labels Informed Feature Selection</h4> + <p> + Pour les problèmes de sélection de variables, il n'est pas + toujours pertinent d'obtenir de bons résultats en + régression. Ceci débloque une opportunité pour utiliser des + variables latentes. C'est l'approche développée par l'algorithme + <emph>MIFS</emph>, pour <emph>Multi-Labels Informed Feature + Selection</emph> <h:cite href="mifs"/>. Elle se fonde sur + plusieurs hypothèses, qui sont intégrées dans une même fonction + objectif. + </p> + <p> + Tout d'abord, <emph>MIFS</emph> propose une abstraction des + labels. Concrètement, il faut sélectionner un nombre de labels + latents, <h:eq>1 \leq o \leq m</h:eq>, et introduire une matrice + de pseudo-labels <h:eq>V \in \mathbb{R}^{n, o}</h:eq> ainsi + qu'une matrice <h:eq>B \in \mathbb{R}^{o, m}</h:eq> de sorte à + substituer <h:eq>VB</h:eq> à <h:eq>Y</h:eq>, et à proposer un + apprentissage de <h:eq>V</h:eq> : + </p> + <h:mini> + <h:variables> + W \in \mathbb{R}^{d, o}, V \in \mathbb{R}^{n, o}, B \in \mathbb{R}^{o, m} + </h:variables> + <h:objective> + \left\|XW - V\right\|_F^2 + \alpha \left\|Y - VB\right\|_F^2 + </h:objective> + </h:mini> + <p> + Ensuite, une régularisation Laplacienne introduit l'hypothèse + suivante : pour chaque pseudo-label, deux individus proches ont + des valeurs proches. Enfin, la régularisation sur les lignes de + la matrice <h:eq>W</h:eq> permet d'obtenir un modèle sparse par + ligne, ce qui permet de guider la sélection de variables. + </p> + <h:mini> + <h:variables> + W \in \mathbb{R}^{d, o}, V \in \mathbb{R}^{n, o}, B \in \mathbb{R}^{o, m} + </h:variables> + <h:objective> + \left\|XW - V\right\|_F^2 + \alpha \left\|Y - VB\right\|_F^2 + \beta \mathrm{tr} \left(V'LV\right) + \gamma \left\|W\right\|_{2, 1} + </h:objective> + </h:mini> + <p> + La fonction objectif est convexe en chacune de ces variables ; + l'algorithme MIFS choisit une optimisation alternée pour + l'optimisation. + </p> + <h1 short="LapS3L">Régression Laplacienne semi-supervisée</h1> + <h:résumé-chapitre> + <p> + Dans ce chapitre, nous présentons notre première contribution + sur la régression semi-supervisée utilisant une version + régularisée de l'algorithme <emph>SSSL</emph> + <h:cite href="ji_simple_2012"/>. Nous commençons par décrire + les travaux liés, puis nous décrivons l'approche proposée, + après quoi nous montrerons à travers deux études + expérimentales l'apport de notre proposition. + </p> + <p> + L'algorithme <emph>SSSL</emph> de base consiste en deux étapes + distinctes : un changement d'espace non supervisé, puis une + régression simple dans ce nouvel espace. Nous proposons + d'emprunter la même idée du changement d'espace original, mais + en adoptant une régularisation Laplacienne dans le nouvel + espace ainsi obtenu. + </p> + </h:résumé-chapitre> + <h2>Introduction</h2> + <p> + À cause de la prolifération des données partiellement + labellisées, l'apprentissage automatique a connu des + développements majeurs dans le contexte semi-supervisé + <h:cite href="chapelle_semi-supervised_2006"/>. Cette tendance + est due d'une part à la difficulté de la tâche de labellisation, + et d'autre part au coût associé lorsque la labellisation est + possible. L'apprentissage semi-supervisé est un cas particulier + de l'apprentissage faiblement labellisé + <h:cite href="li_convex_2013"/>, qui consiste en général en + l'apprentissage d'une fonction objectif à partir de données + contenant à la fois des individus labellisés et des individus + non-labellisés. Ces situations peuvent être abordées par deux + classes d'approches : l'une fondée sur la propagation des + labels, dans le but d'utiliser des méthodes supervisées + <h:cite href="zhu_semi-supervised_nodate"/>, et l'autre fondée + sur la transformation des données labellisées en contraintes à + intégrer dans un processus non-supervisé de clustering + <h:cite href="basu_constrained_2009"/>. Nous nous concentrons + sur la première classe d'approches, avec un défi particulier : + il s'agit d'apprendre à partir d'un petit sous-ensemble + supervisé, en comparaison de l'ensemble non supervisé. Dans ce + contexte semi-supervisé, la littérature a connu une extension + significative depuis les vingt dernières années, en particulier + pour la classification, grâce à des approches populaires comme + le self-training <h:cite href="chapelle_semi-supervised_2006"/>, + le co-training <h:cite href="blum_combining_1998"/>, le SVM + transductif ou S<sup>3</sup>VM + <h:cite href="joachims1999transductive,bennett1999semi"/>, les + approches fondées sur des graphes + <h:cite href="blum_learning_2001"/> et des approches génératives + <h:cite href="nigam2000text"/>. Dans ce paradigme particulier, + les problèmes de régression ont aussi suscité l'intérêt de + plusieurs travaux de recherche que nous pouvons citer de façon + non exhaustive. Les approches sont diverses : fondées sur la + régression linéaire + <h:cite href="azriel_semi-supervised_2016,ji_simple_2012"/>, + logistique <h:cite href="amini_semi-supervised_2002"/>, ou + Laplacienne + <h:cite href="cai_semi-supervised_2006,belkin_manifold_2006"/> ; + d'autres approches sont fondées sur le co-training + <h:cite href="zhou_semi-supervised_nodate"/> ; ou fonctionnent + avec des contraintes spécifiques liées à l'ordre de préférence + des données non labellisées + <h:cite href="zhu_semi-supervised_nodate"/> ou leur distribution + géométrique dans des espaces de haute dimension + <h:cite href="ryan_semi-supervised_2015,moscovich_minimax-optimal_nodate"/>. + </p> + <h2>Travaux liés</h2> + <p> + L'algorithme SSSL (<emph>Simple algorithm for Semi-Supervised + Learning</emph>) <h:cite href="ji_simple_2012"/> se décompose + en deux étapes simples : + </p> + <ol> + <li> + Extraction de variables non supervisée au moyen d'une k-PCA + (<emph>kernel PCA</emph>, ACP avec un noyau) ; + </li> + <li> + Apprentissage supervisé dans ce nouvel espace. + </li> + </ol> + <p> + Sous certaines hypothèses vis-à-vis des données, il est possible + de garantir que dans la classe de fonctions recherchée, + l'algorithme fournit une fonction ayant une erreur de régression + minimale (à une constante près), cette erreur de généralisation + théorique restant inférieure à ce que l'on obtiendrait sans les + individus non labellisés. Ces hypothèses portent sur : + </p> + <ul> + <li> + l'erreur de régression minimale sur la classe de recherche des + fonctions ; + </li> + <li> + la distribution des valeurs propres de la matrice de noyau ; + </li> + <li> + les vecteurs propres de cette matrice ; + </li> + <li> + le nombre d'individus non labellisés. + </li> + </ul> + <p> + L'algorithme <emph>SSSL</emph> permet de rechercher une fonction + de prédiction qui puisse s'écrire de la manière + suivante. Si <h:eq>N</h:eq> désigne le nombre d'individus y + compris les non labellisés de l'ensemble d'apprentissage, + et <h:eq>x_i \in \mathcal{X}</h:eq> désigne le + <h:eq>i</h:eq><sup>ième</sup> individu de l'ensemble + d'apprentissage, on définit une fonction de noyau <h:eq>\kappa + \colon \mathcal{X} \times \mathcal{X} \to \mathbb{R}</h:eq>. On + peut également définir la fonction <h:eq>\hat L_N</h:eq> + suivante : + </p> + <h:equation> + \hat L_N \colon + \begin{array}{ccc} + \left(\mathcal{X} \to \mathbb{R}\right) &\to& \left(\mathcal{X} \to \mathbb{R}\right) \\ + f &\mapsto& x \mapsto \frac 1 N \sum_{i = 1} ^ N \kappa (x_i, x) f (x_i) + \end{array} + </h:equation> + <p> + On note les valeurs propres de cet opérateur linéaire + <h:eq>\left(\hat \lambda\right)_{k = 1} ^ {N}</h:eq> et ses + fonctions propres <h:eq>\left(\phi\right)_{k = 1} ^ N</h:eq>. La + fonction de prédiction est recherchée comme une combinaison + linéaire des <h:eq>s \leq N</h:eq> fonctions propres ayant la + plus grande valeur propre : + </p> + <h:equation> + f \colon x \mapsto \sum_{k = 1} ^ s \Gamma_{k} \hat \phi_{k} (x) + </h:equation> + <p> + Les coefficients <h:eq>\Gamma</h:eq> peuvent être obtenus tout + simplement par une régression aux moindres carrés, c'est-à-dire + en minimisant l'erreur de régression (<h:eq>z</h:eq> désigne le + vecteur de labels pour les individus labellisés) : + </p> + <h:mini> + <h:variables>\Gamma \in \mathbb{R}^{d}</h:variables> + <h:objective>\left\|f (x) - z\right\|_2^2</h:objective> + </h:mini> + <p> + Par conséquent, les valeurs propres elles-mêmes de <h:eq>\hat + L_N</h:eq> ne sont pas utilisées. + </p> + <p> + La régularisation Laplacienne que nous utilisons + <h:cite href="belkin_manifold_2006"/> ne considère pas les + labels des données, ce qui permet d'utiliser tous les individus, + y compris ceux de l'ensemble non-supervisé. À partir de leurs + similarités dans l'espace des variables, un graphe est + construit. Les nœuds sont les individus, et les arêtes indiquent + des individus similaires. La régularisation consiste à indiquer + que les individus similaires doivent avoir des valeurs de la + variable cible similaires, en minimisant le terme suivant : + </p> + <h:equation> + \sum_{i, j\mathrm{~similaires}} (f (x_i) - f (x_j)) ^ 2 + </h:equation> + <h2>Approche proposée : <emph>LapS3L</emph></h2> + <p> + Bien que le changement d'espace introduit + par <emph>SSSL</emph>(présenté ci-dessus) permette de mieux + traiter certains problèmes de régression semi-supervisée + <h:cite href="ji_simple_2012"/>, elle n'utilise pas les mêmes + hypothèses que la régularisation Laplacienne. Dans le cas + général, il n'est pas possible de conclure à la proximité de + deux individus dans l'espace extrait à partir de deux individus + proches dans l'espace réel. Nous proposons donc de réguler + l'apprentissage en introduisant l'hypothèse suivante : + </p> + <blockquote> + Si deux individus sont proches dans l'espace réel, alors l'écart + de prédiction doit être faible. + </blockquote> + <p> + Nous proposons une nouvelle approche, fondée sur cette + hypothèse, que nous appelons <emph>LapS3L</emph>, pour + <emph>Laplacian-regularized Simple algorithm for Semi-Supervised + Learning</emph>. Nous décrivons dans ce qui suit, ses + différentes étapes. + </p> + <h3>Changement d'espace</h3> + <p> + En reprenant le cadre de l'algorithme <emph>SSSL</emph>, il est + possible de tisser un parallèle entre la décomposition en + valeurs et fonctions propres de <h:eq>\hat L_N</h:eq> et la + décomposition en valeurs propres et vecteurs propres de la + matrice noyau. Ce parallèle permet d'obtenir un algorithme + d'apprentissage en deux temps : obtention des vecteurs propres + de la matrice noyau, puis obtention de ses coefficients. + </p> + <p> + Tout d'abord, cette matrice notée <h:eq>K \in S_N^{+} + (\mathbb{R})</h:eq> est définie comme l'application symétrique + de la fonction <h:eq>\kappa</h:eq> entre chaque individu de + l'ensemble d'apprentissage : + </p> + <h:equation> + \forall i, j \in \{1, ..., N\}, \quad K_{i, j} = \kappa (x_i, x_j) + </h:equation> + <p> + L'analyse des vecteurs propres de <h:eq>K</h:eq> permet + d'obtenir une matrice de vecteurs propres <h:eq>U \in + \mathbb{R}^{N, s}</h:eq>, dont les colonnes sont unitaires. On + peut donc poser le changement de variables suivant : + </p> + <h:equation> + X \gets K' U + </h:equation> + <p> + Dans ce changement de variables, chaque ligne de la + matrice <h:eq>X</h:eq> correspond à un individu de l'ensemble + d'apprentissage. Chaque colonne correspond à une variable + extraite. Le nombre de variables extraites est compris entre 1 + et <h:eq>N</h:eq>. Par conséquent, dans le cas où la matrice de + données est plus longue que large, on peut avoir <h:eq>s > + d</h:eq>. Pour les applications où les données sont en grande + dimension, comme par exemple pour les données textuelles, + d'images ou génétiques, ce n'est pas un problème. Dans les + autres cas, la réduction de dimensionnalité ne peut s'opérer que + si la valeur de l'hyperparamètre <h:eq>s</h:eq> est relativement + faible. + </p> + <p> + Puisque les lignes de <h:eq>X</h:eq> sont aussi les lignes + de <h:eq>\mathcal{V}</h:eq>, il est possible de ne conserver que + les lignes correspondant aux individus labellisés. On obtient + ainsi une sous-matrice <h:eq>X_l \in \mathbb{R}^{n, s}</h:eq>. + </p> + <h3>Régression régularisée</h3> + <p> + Dans la deuxième partie de l'algorithme, l'implémentation + consiste à effectuer une régression simple à partir de ces + nouvelles variables. On obtient donc une liste de <h:eq>s</h:eq> + coefficients, <h:eq>w</h:eq>. + </p> + <h:mini id="reg-sssl"> + <h:variables>w \in \mathbb{R}^s</h:variables> + <h:objective>\left\|{X_l}w - z\right\|_2^2</h:objective> + </h:mini> + <p> + Dans le cas où la fonction <h:eq>\kappa</h:eq> est en fait le + produit scalaire, la formulation de la régression dans le nouvel + ensemble de variables <h:eq>X</h:eq>, <h:ref href="#reg-sssl"/>, + montre qu'il n'y a pas de solution dans le cas où <h:eq>s > + d</h:eq>. L'extraction de variables permet donc dans ce cas une + réduction de dimensionnalité. Dans le cas général, cette + remarque ne tient pas. Par exemple, pour n'importe quel + hyperparamètre <h:eq>\sigma</h:eq> du noyau RBF : + </p> + <h:equation> + \kappa \colon (x_i, x_j) \mapsto e^{-\frac {\left\|x_i - x_j\right\|_2^2} {2 \sigma ^ 2}} + </h:equation> + <p> + La matrice noyau obtenue <h:eq>K</h:eq> est à diagonale + strictement dominante, donc inversible ; par conséquent la + matrice de covariance <h:eq>X'X</h:eq> l'est aussi en + extrayant <h:eq>N</h:eq> valeurs propres. Dans la pratique, les + approximations numériques ne permettent pas de choisir une + grande valeur de <h:eq>s</h:eq>. + </p> + <p> + Étant donné que la prédiction s'effectue directement dans + l'espace extrait, il suffit donc de construire le graphe des + individus à partir des variables d'origine, et d'ajouter un + terme de régularisation dans la fonction objectif linéaire de la + seconde étape. Concrètement, on remplace la régression + <h:ref href="#reg-sssl"/> par la version utilisant la + régularisation Laplacienne <h:ref href="#reg-laps3l"/> : + </p> + <h:mini id="reg-laps3l"> + <h:variables>w \in \mathbb{R} ^ s</h:variables> + <h:objective>\left\|X_l w - z_l\right\|_2^2 + \alpha \left\|w\right\|^2 + \beta [Xw]'L[Xw]</h:objective> + </h:mini> + <p> + Cette approche ne nécessite pas de changer la prédiction ; elle + n'intervient que dans l'apprentissage. + </p> + <h3>Prédiction</h3> + <p> + Pour la prédiction sur un ensemble de + test <h:eq>\mathcal{V}_t</h:eq> à <h:eq>n_t</h:eq> individus, on + commence par appliquer la matrice <h:eq>\kappa</h:eq> entre tous + les individus de l'ensemble labellisé, à gauche, et tous les + individus de l'ensemble de test, à droite. On note le + résultat <h:eq>K_b \in \mathbb{R}^{N, n_t}</h:eq> : + </p> + <h:equation> + \forall i \in \{1, ..., N\}, \quad \forall j \in \{1, ... n_t\}, \quad {K_b}_{i, j} = \kappa (\mathcal{V}_{i, .}, {\mathcal{V}_t}_{j, .}) + </h:equation> + <p> + Le changement de variables est identique à celui effectué pour + l'apprentissage : + </p> + <h:equation> + X_t \gets K_b' U \in \mathbb{R}^{n_t, s} + </h:equation> + <p> + La prédiction est donc opérée par : + </p> + <h:equation>X_t w</h:equation> + <h3>Algorithme</h3> + <p> + L'algorithme <h:ref href="#algorithme-laps3l-train"/> montre les + étapes de l'apprentissage, et l'algorithme + <h:ref href="#algorithme-laps3l-predict"/> décrit la fonction de + prédiction. + </p> + <h:algorithm id="algorithme-laps3l-train"> + <alg:algorithmic> + <alg:donnée><h:eq>\mathcal{V} \in \mathbb{R}^{N, d}</h:eq></alg:donnée> + <alg:donnée><h:eq>z \in \mathbb{R}^{n_l}</h:eq></alg:donnée> + <alg:hyperparamètre><h:eq>s \in \{1, ..., N\}</h:eq></alg:hyperparamètre> + <alg:hyperparamètre><h:eq>\kappa \colon \mathcal{X} \times \mathcal{X} \to \mathbb{R}</h:eq></alg:hyperparamètre> + <alg:hyperparamètre>matrice Laplacienne du graphe des individus, <h:eq>L \in \mathbb{R}^{N, N}</h:eq></alg:hyperparamètre> + <alg:hyperparamètre><h:eq>\alpha > 0</h:eq></alg:hyperparamètre> + <alg:hyperparamètre><h:eq>\beta > 0</h:eq></alg:hyperparamètre> + <alg:state> + Construire la matrice <h:eq>K \in \mathbb{R}^{N, + N}</h:eq> : <h:equation-x>\forall i, j, \quad K_{i, j} = + \kappa (\mathcal{V}_{i, .}, \mathcal{V}_{j, + .})</h:equation-x> + </alg:state> + <alg:state> + Décomposer la matrice <h:eq>K</h:eq> en valeurs propres et + vecteurs propres, sélectionner les <h:eq>s</h:eq> vecteurs + propres ayant la plus grande valeur propre + associée : <h:eq>U \in \mathbb{R}^{N, s}</h:eq> + </alg:state> + <alg:state> + Poser <h:eq>X := K U</h:eq> + </alg:state> + <alg:state> + Sélectionner la sous-matrice <h:eq>Xl \in + \mathbb{R}^{n,s}</h:eq> composée des lignes + de <h:eq>X</h:eq> correspondant aux individus labellisés + </alg:state> + <alg:state> + <h:mini> + <h:variables>w \in \mathbb{R} ^ s</h:variables> + <h:objective>\left\|X_l w - z_l\right\|_2^2 + \alpha \left\|w\right\|^2 + \beta [Xw]'L[Xw]</h:objective> + </h:mini> + </alg:state> + <alg:résultat><h:eq>U \in \mathbb{R}^{N, s}</h:eq></alg:résultat> + <alg:résultat><h:eq>w \in \mathbb{R}^{s}</h:eq></alg:résultat> + </alg:algorithmic> + <figcaption> + Algorithme <emph>LapS3L</emph> : apprentissage + </figcaption> + </h:algorithm> + <h:algorithm id="algorithme-laps3l-predict"> + <alg:algorithmic> + <alg:donnée><h:eq>\mathcal{V} \in \mathbb{R}^{N, d}</h:eq>, <h:eq>\mathcal{V}_t \in \mathbb{R}^{n_t, d}</h:eq></alg:donnée> + <alg:hyperparamètre><h:eq>\kappa \colon \mathcal{X} \times \mathcal{X} \to \mathbb{R}</h:eq></alg:hyperparamètre> + <alg:modèle><h:eq>U \in \mathbb{R}^{N, s}</h:eq></alg:modèle> + <alg:modèle><h:eq>w \in \mathbb{R}^{s}</h:eq></alg:modèle> + <alg:state> + Construire la matrice <h:eq>K_b \in \mathbb{R}^{N, + n_t}</h:eq> : + + <h:equation-x> + \forall i, j, \quad {K_b}_{i, j} = \kappa (\mathcal{V}_{i, .}, {\mathcal{V}_t}_{j, .}) + </h:equation-x> + </alg:state> + <alg:state> + Poser <h:eq>X_t := K_b' U</h:eq> + </alg:state> + <alg:résultat><h:eq>\hat z \gets X_t w</h:eq></alg:résultat> + </alg:algorithmic> + <figcaption> + Algorithme <emph>LapS3L</emph> : prédiction + </figcaption> + </h:algorithm> + <h2>Validation expérimentale</h2> + <p> + Dans cette section, nous présentons une première étude + expérimentale pour valider l'approche proposée sur des données + publiques issues de la littérature. + </p> + <h3>Jeux de données utilisés</h3> + <p> + Les auteurs dans <h:cite href="ji_simple_2012"/> ont identifié + trois jeux de données pour lesquels les hypothèses de + fonctionnement sont + établies : <emph>wine</emph>, <emph>insurance</emph> et + <emph>temperature</emph>. + </p> + <ul> + <li> + <emph>wine</emph> regroupe une évaluation de la composition + chimique de 4898 vins, exprimée sur 11 variables continues, + ainsi qu'un score de qualité attribué à chaque vin + <h:fn><a href="https://archive.ics.uci.edu/ml/datasets/wine+quality">https://archive.ics.uci.edu/ml/datasets/wine+quality</a></h:fn>. La + cible, la qualité, est une valeur continue, ce qui en fait un + jeu de données de régression. La qualité ne suit pas une loi + uniforme : 45% des vins ont une qualité égale à 6, 30% ont une + qualité égale à 5, et 18% une qualité égale à 7. Ainsi, les + valeurs d'erreur de régression doivent être inférieures à la + base suivante : en prédisant toujours 6, on obtient + une <emph>RSME</emph> de 0.89 et une <emph>MAE</emph> de 0.63. + </li> + <li> + <emph>insurance</emph>, aussi appelé COIL2000 + <h:fn> + <a href="https://archive.ics.uci.edu/ml/datasets/Insurance+Company+Benchmark+(COIL+2000)"> + https://archive.ics.uci.edu/ml/datasets/Insurance+Company+Benchmark+(COIL+2000) + </a> + </h:fn>, regroupe des profils de personnes ayant souscrit une + assurance, établis sur 85 variables, et la cible est la + variable binaire indiquant si la personne assurée a une + assurance pour une caravane. Là encore, la cible est + déséquilibrée, puisque seuls 6% des clients ont une assurance + pour une caravane. La base consistant à prédire la valeur + moyenne done une <emph>RMSE</emph> de 0.237, et prédire 0 + donne une <emph>RMSE</emph> de 0.244 et une <emph>MAE</emph> + de 0.06. + </li> + <li> + <emph>temperature</emph> décrit la température de la haute + atmosphère, dans un jeu de données qui n'est pas public. Par + conséquent, nous ne l'utilisons pas dans notre étude. + </li> + </ul> + <p> + Comme dans l’article original, nous conservons de 2% à 9% des + labels des jeux de données. + </p> + <h3>Protocole expérimental</h3> + <p> + L'algorithme <emph>LapS3L</emph> a plusieurs hyperparamètres : + </p> + <ul> + <li> + la définition du noyau, et éventuellement la valeur de la + bande passante si c'est un noyau gaussien ; + </li> + <li> + le nombre de composantes principales ; + </li> + <li> + le régulariseur ridge <h:eq>\alpha</h:eq> ; + </li> + <li> + le régulariseur Laplacien <h:eq>\beta</h:eq> ; + </li> + <li> + la définition du graphe des individus. + </li> + </ul> + <p> + Les valeurs de ces hyperparamètres sont recherchées dans les + ensembles suivants : + </p> + <ul> + <li> + noyau : l'ensemble composé du noyau utilisant la similarité + cosinus, du noyau constitué par la matrice de Gram, et du + noyau gaussien dont la bande passante <h:eq>\sigma</h:eq> + prend les valeurs dans <h:eq>\{0.01, 0.05, 0.1, 0.5, 1, 5, 10, + 50, 100\}</h:eq> ; + </li> + <li> + le nombre de composantes principales est sélectionné dans + l'ensemble entre {1, 2, 5, 10, 20, 50, 100, 200}. Une valeur + supérieure à 200 nuit à l'apprentissage du <emph>SSSL</emph>, + puisque la matrice de variables extraites <h:eq>X</h:eq> a un + rang trop faible, d'une part, et le temps d'apprentissage est + trop long, d'autre part ; + </li> + <li> + le graphe des individus est défini comme suit : on commence + par le construire complet, les arêtes étant valuées par la + similarité cosinus entre individus dans l'ensemble des + variables original, puis il est élagué de façon à ne conserver + que les 10 plus proches voisins symétriques ; + </li> + <li> + les deux régulariseurs sont choisis dans + l'ensemble <h:eq>\{\left(10^{k}\right)_{k = -4} ^ 4\}</h:eq>. + </li> + </ul> + <p> + La procédure de tuning est la suivante : + </p> + <ul> + <li> + <p>Répéter 10 fois les opérations suivantes :</p> + <ul> + <li> + Sélectionner 90% du jeu de données labellisé pour + l'apprentissage, 10% pour le test (les données non + labellisées sont utilisées pour l'apprentissage) ; + </li> + <li> + <p> + Répéter 10 fois (insurance) ou 20 fois (wine) : + </p> + <ul> + <li> + Tirer avec remise une valeur pour chaque + hyperparamètre, + </li> + <li> + Évaluer la performance (<emph>RMSE</emph>) + de <emph>LapS3L</emph> et <emph>SSSL</emph> en + validation croisée à 10 folds sur l'ensemble + d'apprentissage labellisé, en y ajoutant les individus + non labellisés ; + </li> + </ul> + </li> + <li> + Sélectionner la meilleure valeur des hyperparamètres ; + </li> + <li> + Entraîner <emph>SSSL</emph> et <emph>LapS3L</emph> sur + l'ensemble d'apprentissage en utilisant ces + hyperparamètres ; + </li> + <li> + Tester sur l'ensemble de + test : <emph>RMSE</emph>, <emph>MAE</emph>, + <emph>RRSE</emph>, <emph>RAE</emph>. + </li> + </ul> + </li> + <li> + Retourner la moyenne et l'écart-type de chacune de ces + métriques. + </li> + </ul> + <p> + Le nombre de points du paramétrage est plus restreint pour le + jeu de données <emph>insurance</emph>, car il comporte environ + deux fois plus d'individus que <emph>wine</emph>. + </p> + <p> + Nous utilisons les quatre métriques suivantes pour évaluer la + régression semi-supervisée, où <h:eq>z</h:eq> désigne le label + de l'ensemble de test, <h:eq>\hat z</h:eq> la prédiction, et + <h:eq>\bar z</h:eq> la valeur moyenne sur l'ensemble + d'apprentissage : + </p> + <ul> + <li> + <emph>RMSE</emph> ou <emph>Root Mean Squared Error</emph>, + racine de l'erreur quadratique + moyenne : <h:equation-x>\mathrm{RMSE} = \sqrt{\frac 1 {n_t} + \left\|z - \hat z\right\|_2^2}</h:equation-x> + </li> + <li> + <emph>MAE</emph> ou <emph>Mean Absolute Error</emph>, erreur + absolue moyenne : <h:equation-x>\mathrm{MAE} = \frac 1 {n_t} + \left|z - \hat z\right|</h:equation-x> + </li> + <li> + <emph>RRSE</emph> ou <emph>Root Relative Squared Error</emph>, + racine de l'erreur quadratique + relative, <h:equation-x>\mathrm{RRSE} = \sqrt{\frac {\left\|z + - \hat z\right\|_2^2} {\left\|z - \bar + z\right\|_2^2}}</h:equation-x> + </li> + <li> + <emph>RAE</emph> ou <emph>Relative Absolute Error</emph>, + erreur en valeur absolue relative, <h:equation-x>\mathrm{RAE} + = \frac {\left|z - \hat z\right|_2^2} {\left|z - \bar + z\right|_2^2}</h:equation-x> + </li> + </ul> + <h3>Résultats</h3> + <p> + Les résultats de la comparaison sont visibles dans les tables + <h:ref href="#results-laps3l-rmse"/>-<h:ref href="#results-laps3l-rae"/>. + </p> + <table latex-align="|l|cc|"> + <caption id="results-laps3l-rmse"> + Comparaison entre <emph>LapS3L</emph> et <emph>SSSL</emph> + sur <emph>wine</emph> et <emph>insurance</emph>, métrique + RMSE. + </caption> + <thead> + <tr><th>dataset</th> <th><strong>LapS3L</strong></th><th> <emph>SSSL</emph></th></tr> + </thead> + <tbody> + <tr><td>insurance (2%)</td><td><strong>0.20 ± 0.03</strong></td><td>0.21 ± 0.03</td></tr> + <tr><td>insurance (3%)</td><td><strong>0.21 ± 0.02</strong></td><td>0.21 ± 0.02</td></tr> + <tr><td>insurance (4%)</td><td><strong>0.21 ± 0.02</strong></td><td>0.22 ± 0.02</td></tr> + <tr><td>insurance (5%)</td><td><strong>0.22 ± 0.02</strong></td><td>0.22 ± 0.02</td></tr> + <tr><td>insurance (6%)</td><td><strong>0.22 ± 0.02</strong></td><td>0.22 ± 0.02</td></tr> + <tr><td>insurance (7%)</td><td><strong>0.22 ± 0.02</strong></td><td>0.22 ± 0.02</td></tr> + <tr><td>insurance (8%)</td><td><strong>0.22 ± 0.02</strong></td><td>0.23 ± 0.02</td></tr> + <tr><td>insurance (9%)</td><td><strong>0.23 ± 0.01</strong></td><td>0.23 ± 0.02</td></tr> + <tr><td>wine (2%)</td> <td><strong>0.77 ± 0.06</strong></td><td>0.82 ± 0.06</td></tr> + <tr><td>wine (3%)</td> <td><strong>0.75 ± 0.05</strong></td><td>0.80 ± 0.05</td></tr> + <tr><td>wine (4%)</td> <td><strong>0.77 ± 0.06</strong></td><td>0.82 ± 0.05</td></tr> + <tr><td>wine (5%)</td> <td><strong>0.78 ± 0.05</strong></td><td>0.84 ± 0.06</td></tr> + <tr><td>wine (6%)</td> <td><strong>0.78 ± 0.03</strong></td><td>0.84 ± 0.04</td></tr> + <tr><td>wine (7%)</td> <td><strong>0.77 ± 0.04</strong></td><td>0.84 ± 0.03</td></tr> + <tr><td>wine (8%)</td> <td><strong>0.77 ± 0.04</strong></td><td>0.84 ± 0.04</td></tr> + <tr><td>wine (9%)</td> <td><strong>0.77 ± 0.04</strong></td><td>0.84 ± 0.04</td></tr> + </tbody> + </table> + <table latex-align="|l|cc|"> + <caption id="results-laps3l-mae"> + Comparaison entre <emph>LapS3L</emph> et <emph>SSSL</emph> + sur <emph>wine</emph> et <emph>insurance</emph>, métrique + MAE. + </caption> + <thead> + <tr><th>dataset</th> <th><strong>LapS3L</strong></th><th> <emph>SSSL</emph></th></tr> + </thead> + <tbody> + <tr><td>insurance (2%)</td><td><strong>0.07 ± 0.02</strong></td><td>0.12 ± 0.02</td></tr> + <tr><td>insurance (3%)</td><td><strong>0.07 ± 0.03</strong></td><td>0.11 ± 0.01</td></tr> + <tr><td>insurance (4%)</td><td><strong>0.09 ± 0.03</strong></td><td>0.11 ± 0.02</td></tr> + <tr><td>insurance (5%)</td><td><strong>0.09 ± 0.03</strong></td><td>0.11 ± 0.02</td></tr> + <tr><td>insurance (6%)</td><td><strong>0.09 ± 0.03</strong></td><td>0.11 ± 0.02</td></tr> + <tr><td>insurance (7%)</td><td><strong>0.10 ± 0.02</strong></td><td>0.11 ± 0.02</td></tr> + <tr><td>insurance (8%)</td><td><strong>0.10 ± 0.03</strong></td><td>0.11 ± 0.02</td></tr> + <tr><td>insurance (9%)</td><td><strong>0.11 ± 0.01</strong></td><td>0.11 ± 0.01</td></tr> + <tr><td>wine (2%)</td> <td><strong>0.62 ± 0.05</strong></td><td>0.67 ± 0.05</td></tr> + <tr><td>wine (3%)</td> <td><strong>0.60 ± 0.04</strong></td><td>0.65 ± 0.05</td></tr> + <tr><td>wine (4%)</td> <td><strong>0.60 ± 0.05</strong></td><td>0.66 ± 0.04</td></tr> + <tr><td>wine (5%)</td> <td><strong>0.61 ± 0.04</strong></td><td>0.67 ± 0.04</td></tr> + <tr><td>wine (6%)</td> <td><strong>0.61 ± 0.03</strong></td><td>0.68 ± 0.03</td></tr> + <tr><td>wine (7%)</td> <td><strong>0.61 ± 0.03</strong></td><td>0.67 ± 0.03</td></tr> + <tr><td>wine (8%)</td> <td><strong>0.61 ± 0.03</strong></td><td>0.67 ± 0.04</td></tr> + <tr><td>wine (9%)</td> <td><strong>0.61 ± 0.03</strong></td><td>0.67 ± 0.04</td></tr> + </tbody> + </table> + <table latex-align="|l|cc|"> + <caption id="results-laps3l-rrse"> + Comparaison entre <emph>LapS3L</emph> et <emph>SSSL</emph> + sur <emph>wine</emph> et <emph>insurance</emph>, métrique + RRSE. + </caption> + <thead> + <tr><th>dataset</th> <th><strong>LapS3L</strong></th><th> <emph>SSSL</emph></th></tr> + </thead> + <tbody> + <tr><td>insurance (2%)</td><td><strong>0.71 ± 0.13</strong></td><td>1.04 ± 0.04</td></tr> + <tr><td>insurance (3%)</td><td><strong>0.86 ± 0.10</strong></td><td>1.03 ± 0.03</td></tr> + <tr><td>insurance (4%)</td><td><strong>0.91 ± 0.11</strong></td><td>1.02 ± 0.03</td></tr> + <tr><td>insurance (5%)</td><td><strong>0.95 ± 0.07</strong></td><td>1.01 ± 0.01</td></tr> + <tr><td>insurance (6%)</td><td><strong>0.96 ± 0.05</strong></td><td>1.00 ± 0.01</td></tr> + <tr><td>insurance (7%)</td><td><strong>0.99 ± 0.03</strong></td><td>1.00 ± 0.01</td></tr> + <tr><td>insurance (8%)</td><td><strong>0.97 ± 0.03</strong></td><td>1.00 ± 0.01</td></tr> + <tr><td>insurance (9%)</td><td><strong>0.99 ± 0.01</strong></td><td>1.00 ± 0.00</td></tr> + <tr><td>wine (2%)</td> <td><strong>0.92 ± 0.05</strong></td><td>0.97 ± 0.03</td></tr> + <tr><td>wine (3%)</td> <td><strong>0.90 ± 0.05</strong></td><td>0.96 ± 0.04</td></tr> + <tr><td>wine (4%)</td> <td><strong>0.90 ± 0.03</strong></td><td>0.96 ± 0.02</td></tr> + <tr><td>wine (5%)</td> <td><strong>0.90 ± 0.03</strong></td><td>0.96 ± 0.02</td></tr> + <tr><td>wine (6%)</td> <td><strong>0.89 ± 0.02</strong></td><td>0.96 ± 0.01</td></tr> + <tr><td>wine (7%)</td> <td><strong>0.89 ± 0.02</strong></td><td>0.96 ± 0.02</td></tr> + <tr><td>wine (8%)</td> <td><strong>0.88 ± 0.02</strong></td><td>0.96 ± 0.02</td></tr> + <tr><td>wine (9%)</td> <td><strong>0.88 ± 0.02</strong></td><td>0.96 ± 0.01</td></tr> + </tbody> + </table> + <table latex-align="|l|cc|"> + <caption id="results-laps3l-rae"> + Comparaison entre <emph>LapS3L</emph> et <emph>SSSL</emph> + sur <emph>wine</emph> et <emph>insurance</emph>, métrique + RAE. + </caption> + <thead> + <tr><th>dataset</th> <th><strong>LapS3L</strong></th><th> <emph>SSSL</emph></th></tr> + </thead> + <tbody> + <tr><td>insurance (2%)</td><td><strong>0.47 ± 0.17</strong></td><td>1.02 ± 0.02</td></tr> + <tr><td>insurance (3%)</td><td><strong>0.61 ± 0.25</strong></td><td>1.01 ± 0.02</td></tr> + <tr><td>insurance (4%)</td><td><strong>0.76 ± 0.28</strong></td><td>1.01 ± 0.02</td></tr> + <tr><td>insurance (5%)</td><td><strong>0.82 ± 0.25</strong></td><td>1.00 ± 0.02</td></tr> + <tr><td>insurance (6%)</td><td><strong>0.80 ± 0.25</strong></td><td>1.00 ± 0.01</td></tr> + <tr><td>insurance (7%)</td><td><strong>0.93 ± 0.15</strong></td><td>1.00 ± 0.01</td></tr> + <tr><td>insurance (8%)</td><td><strong>0.89 ± 0.20</strong></td><td>0.99 ± 0.01</td></tr> + <tr><td>insurance (9%)</td><td><strong>0.99 ± 0.01</strong></td><td>1.00 ± 0.02</td></tr> + <tr><td>wine (2%)</td> <td><strong>0.95 ± 0.07</strong></td><td>1.01 ± 0.03</td></tr> + <tr><td>wine (3%)</td> <td><strong>0.92 ± 0.07</strong></td><td>0.99 ± 0.03</td></tr> + <tr><td>wine (4%)</td> <td><strong>0.91 ± 0.06</strong></td><td>1.00 ± 0.03</td></tr> + <tr><td>wine (5%)</td> <td><strong>0.92 ± 0.05</strong></td><td>1.00 ± 0.03</td></tr> + <tr><td>wine (6%)</td> <td><strong>0.92 ± 0.04</strong></td><td>1.01 ± 0.02</td></tr> + <tr><td>wine (7%)</td> <td><strong>0.91 ± 0.03</strong></td><td>1.00 ± 0.03</td></tr> + <tr><td>wine (8%)</td> <td><strong>0.91 ± 0.04</strong></td><td>1.00 ± 0.03</td></tr> + <tr><td>wine (9%)</td> <td><strong>0.91 ± 0.03</strong></td><td>1.00 ± 0.03</td></tr> + </tbody> + </table> + <p> + Pour la métrique RMSE (table + <h:ref href="#results-laps3l-rmse"/>), <emph>LapS3L</emph> + et <emph>SSSL</emph> obtiennent une erreur de régression + inférieure à 0.244 (pour insurance) et 0.89 (pour wine), qui + étaient les lignes de base à dépasser. La métrique RMSE a été + utilisée pour le tuning des hyperparamètres, ce qui n'est pas le + cas pour la métrique MAE, dont la ligne de base n'est pas + toujours respectée. + </p> + <p> + Plus précisément, la table <h:ref href="#results-laps3l-mae"/> + montre que <emph>LapS3L</emph> reste inférieur à la ligne de + base pour wine (0.63), mais pas pour insurance + (0.06). <emph>SSSL</emph> ne respecte aucune de ces lignes de + base. + </p> + <p> + Sur les deux jeux de données, quel que soit le nombre + d'individus labellisés (entre 2% et 9% du total) et quelle que + soit la métrique envisagée, l'approche <emph>LapS3L</emph> donne + un meilleur résultat que l'approche <emph>SSSL</emph>. Ce n'est + pas surprenant, puisque <emph>LapS3L</emph> est une + généralisation de <emph>SSSL</emph>. Cela signifie en revanche + qu'un tuning à 10 points (respectivement 20) pour insurance + (respectivement wine) est suffisant pour explorer un espace de + recherche de la solution plus grand. Pour les métriques + relatives, l'écart-type est plus faible pour <emph>SSSL</emph>, + mais ce n'est pas très pertinent : en effet, pour les métriques + relatives, les deux approches tendent à donner un résultat + proche de 1. Par conséquent, <emph>LapS3L</emph> donnant parfois + une erreur de régression bien plus faible, obtient un écart-type + plus grand. + </p> + <p> + En regardant de plus près le jeu de + données <emph>insurance</emph>, on s'aperçoit que les + performances sont bonnes pour un petit nombre de données + labellisées (cf figure <h:ref href="#fig-rmse-insurance"/>). En + effet, les limites imposées pour le tuning ne permettent pas de + contrer le sur-apprentissage. + </p> + <figure> + <img src="images/insurance_rmse.svg" /> + <figcaption id="fig-rmse-insurance"> + Performance de <emph>LapS3L</emph> et <emph>SSSL</emph> + sur <emph>insurance</emph> (métrique RMSE) + </figcaption> + </figure> + <p> + La métrique MAE, toujours sur le jeu de + données <emph>insurance</emph> + (figure <h:ref href="#fig-mae-insurance"/>), montre une tendance + similaire pour <emph>LapS3L</emph>, mais pas + pour <emph>SSSL</emph>, ce qui justifie la pertinence de notre + approche. + </p> + <figure> + <img src="images/insurance_mae.svg" /> + <figcaption id="fig-mae-insurance"> + Performance de <emph>LapS3L</emph> et <emph>SSSL</emph> + sur <emph>insurance</emph> (métrique MAE) + </figcaption> + </figure> + <p> + Nous pouvons donc conclure que l'approche proposée, en tant que + généralisation stricte de <emph>SSSL</emph>, ne nécessite pas un + tuning plus précis pour donner de meilleures performances. Il + nous reste à vérifier si notre approche fonctionne hors des + hypothèses de fonctionnement de <emph>SSSL</emph>. + </p> + <h2>Étude comparative</h2> + <p> + Dans cette section, nous élargissons la comparaison des + performance à différents algorithmes sur d'autres jeux de + données publics divers. + </p> + <h3>Jeux de données</h3> + <p> + Nous utilisons les jeux de données publics suivants : + </p> + <ul> + <li> + <emph>Concrete Compressive Strength</emph> + (<emph>concrete</emph>) + <h:fn> + <a href="https://archive.ics.uci.edu/ml/datasets/Concrete+Compressive+Strength"> + https://archive.ics.uci.edu/ml/datasets/Concrete+Compressive+Strength + </a> + </h:fn> + observe des échantillons de béton comparant leur composition + et leur âge, afin d'en déduire la pression de compression. Ce + jeu de données comprend 1030 échantillons pour 9 + variables. Afin de pouvoir appliquer la fonction de noyau, + toutes les variables du jeu de données sont normalisées de + manière à avoir une moyenne nulle et un écart-type égal à 1 ; + </li> + <li> + <emph>Airfoil Self-Noise</emph> + (<emph>airfoil</emph>) + <h:fn> + <a href="https://archive.ics.uci.edu/ml/datasets/Airfoil+Self-Noise"> + https://archive.ics.uci.edu/ml/datasets/Airfoil+Self-Noise + </a> + </h:fn> + observe des hélices, afin d'en déduire le niveau de bruit. Il + comprend 1503 observations pour 5 variables. Pour ce jeu de + données, toutes les variables ont été redimensionnées de + manière à obtenir une moyenne nulle et un écart-type égal à + 1 ; + </li> + <li> + <emph>Behavior of the urban traffic of the city of Sao Paulo in Brazil</emph> + (<emph>behavior</emph>) + <h:fn> + <a href="https://archive.ics.uci.edu/ml/datasets/Behavior+of+the+urban+traffic+of+the+city+of+Sao+Paulo+in+Brazil"> + https://archive.ics.uci.edu/ml/datasets/Behavior+of+the+urban+traffic+of+the+city+of+Sao+Paulo+in+Brazil + </a> + </h:fn> + mesure le retard du réseau comme la réponse à divers + événements. Il ne comprend que 135 individus pour 18 + variables ; + </li> + <li> + <emph>Communities and Crime Data Set</emph> + (<emph>crimepredict</emph>) + <h:fn> + <a href="https://archive.ics.uci.edu/ml/datasets/Communities+and+Crime"> + https://archive.ics.uci.edu/ml/datasets/Communities+and+Crime + </a> + </h:fn> + mesure le nombre de crimes violents dans un certain nombre de + communes aux États-Unis. Il comprend 1994 individus pour 123 + variables (en enlevant les variables d'index) décrivant les + communes, y compris leur démographie. Ce jeu de données a été + sélectionné parce qu'il contenait un nombre d'individus + suffisamment faible pour l'apprentissage, avec des variables + normalisées (ce qui permet d'appliquer directement une + fonction de noyau). + </li> + </ul> + <h3>Algorithmes</h3> + <p> + Dans la version non linéaire de + l'algorithme <emph>LapRLS</emph>, il s'agit de minimiser la + fonction objectif suivante : + </p> + <h:mini> + <h:variables>f \in \mathcal{H}_{\kappa}</h:variables> + <h:objective> + \left\|\hat {f_l} - {y_l}\right\|_2^2 + \alpha \left\|f\right\|_{\kappa}^2 + \beta \hat {f}' L \hat f + </h:objective> + </h:mini> + <p> + Ici, <h:eq>\mathcal{H}_{\kappa}</h:eq> désigne un espace de + Hilbert à noyau reproduisant. Dans cet espace, une + fonction <h:eq>f</h:eq> s'écrit de la façon suivante : + </p> + <h:equation> + x \mapsto \sum_{i = 1}^N \alpha_i \kappa (x_i, x) + </h:equation> + <p> + On note également <h:eq>\hat f</h:eq> l'application de la + fonction <h:eq>f</h:eq> sur le jeu d'apprentissage (<h:eq>\hat + {f_l}</h:eq> uniquement sur les individus labellisés). La + fonction objectif peut être résolue de manière analytique en + posant : + </p> + <h:equation> + \alpha \gets \left[JK + \alpha I + \beta LK\right]^{-1} J Y + </h:equation> + <p> + avec <h:eq>J</h:eq> la matrice diagonale de + dimension <h:eq>N,N</h:eq> dont la diagonale en <h:eq>(i, + i)</h:eq> vaut 1 si l'individu <h:eq>i</h:eq> est + labellisé, <h:eq>0</h:eq> sinon. + </p> + <p> + En plus de la version non linéaire de <emph>LapRLS</emph>, ainsi + que de <emph>SSSL</emph>, nous comparons avec une forêt + aléatoire (<emph>TB</emph> pour <emph>Tree Bagging</emph> + <h:cite href="ho1995random"/>) comprenant entre 1 et 1000 + arbres, et l'algorithme <emph>ν-SVR</emph> + <h:cite href="nusvm"/>. + </p> + <p> + La comparaison de ces algorithmes sur les 4 jeux de données + donnent les résultats dans la table + <h:ref href="#tbl-laps3l-vs-the-world"/>. + </p> + <table latex-align="llllll"> + <caption id="tbl-laps3l-vs-the-world"> + Comparaison de <emph>LapS3L</emph> contre d’autres + algorithmes de régression, métrique RMSE + </caption> + <thead> + <tr> + <th>dataset</th> + <th><strong>LapS3L</strong></th> + <th><emph>LapRLS</emph></th> + <th><emph>SSSL</emph></th> + <th><emph>ν-SVR</emph></th> + <th><emph>TB</emph></th> + </tr> + </thead> + <tbody> + <tr> + <td>airfoil (2%)</td> + <td><strong>0.65 ± 0.09</strong></td> + <td>0.73 ± 0.11</td> + <td>0.70 ± 0.13</td> + <td>0.78 ± 0.09</td> + <td>0.74 ± 0.07</td> + </tr> + <tr> + <td>airfoil (3%)</td> + <td><strong>0.67 ± 0.08</strong></td> + <td>0.69 ± 0.11</td> + <td>0.75 ± 0.10</td> + <td>0.80 ± 0.11</td> + <td>0.75 ± 0.08</td> + </tr> + <tr> + <td>airfoil (4%)</td> + <td><strong>0.64 ± 0.09</strong></td> + <td>0.66 ± 0.10</td> + <td>0.71 ± 0.07</td> + <td>0.78 ± 0.10</td> + <td>0.68 ± 0.07</td> + </tr> + <tr> + <td>airfoil (5%)</td> + <td><strong>0.62 ± 0.08</strong></td> + <td>0.63 ± 0.09</td> + <td>0.72 ± 0.05</td> + <td>0.77 ± 0.06</td> + <td>0.68 ± 0.06</td> + </tr> + <tr> + <td>airfoil (6%)</td> + <td>0.63 ± 0.06</td> + <td><strong>0.62 ± 0.07</strong></td> + <td>0.72 ± 0.04</td> + <td>0.77 ± 0.05</td> + <td>0.66 ± 0.05</td> + </tr> + <tr> + <td>airfoil (7%)</td> + <td><strong>0.59 ± 0.05</strong></td> + <td>0.60 ± 0.06</td> + <td>0.71 ± 0.05</td> + <td>0.75 ± 0.04</td> + <td>0.64 ± 0.04</td> + </tr> + <tr> + <td>airfoil (8%)</td> + <td>0.59 ± 0.04</td> + <td><strong>0.57 ± 0.06</strong></td> + <td>0.70 ± 0.05</td> + <td>0.74 ± 0.03</td> + <td>0.61 ± 0.04</td> + </tr> + <tr> + <td>airfoil (9%)</td> + <td>0.57 ± 0.03</td> + <td><strong>0.55 ± 0.05</strong></td> + <td>0.70 ± 0.05</td> + <td>0.73 ± 0.03</td> + <td>0.58 ± 0.03</td> + </tr> + <tr> + <td>behavior (2%)</td> + <td><strong>4.15 ± 2.73</strong></td> + <td>5.04 ± 2.58</td> + <td><emph>erreur</emph></td> + <td><emph>erreur</emph></td> + <td>5.26 ± 3.59</td> + </tr> + <tr> + <td>behavior (3%)</td> + <td><strong>2.64 ± 1.56</strong></td> + <td>3.84 ± 1.76</td> + <td>3.64 ± 3.68</td> + <td>3.08 ± 1.74</td> + <td>3.26 ± 1.81</td> + </tr> + <tr> + <td>behavior (4%)</td> + <td><strong>2.42 ± 0.82</strong></td> + <td>3.60 ± 1.48</td> + <td>3.98 ± 2.91</td> + <td>3.14 ± 0.97</td> + <td>3.09 ± 1.21</td> + </tr> + <tr> + <td>behavior (5%)</td> + <td><strong>2.48 ± 0.61</strong></td> + <td>3.39 ± 1.03</td> + <td>3.83 ± 2.25</td> + <td>2.61 ± 0.67</td> + <td>3.00 ± 0.92</td> + </tr> + <tr> + <td>behavior (6%)</td> + <td><strong>2.58 ± 0.74</strong></td> + <td>3.66 ± 0.60</td> + <td>3.64 ± 1.75</td> + <td>2.72 ± 0.53</td> + <td>3.06 ± 0.76</td> + </tr> + <tr> + <td>behavior (7%)</td> + <td><strong>2.49 ± 0.97</strong></td> + <td>3.52 ± 0.76</td> + <td>3.05 ± 1.19</td> + <td>2.76 ± 0.96</td> + <td>2.93 ± 0.88</td> + </tr> + <tr> + <td>behavior (8%)</td> + <td><strong>2.57 ± 0.83</strong></td> + <td>3.32 ± 0.68</td> + <td>3.13 ± 0.77</td> + <td>2.77 ± 0.87</td> + <td>2.79 ± 0.69</td> + </tr> + <tr> + <td>behavior (9%)</td> + <td><strong>2.55 ± 0.73</strong></td> + <td>3.35 ± 0.60</td> + <td>2.69 ± 0.81</td> + <td>2.61 ± 0.87</td> + <td>2.78 ± 0.52</td> + </tr> + <tr> + <td>concrete (2%)</td> + <td><strong>0.49 ± 0.12</strong></td> + <td>0.60 ± 0.14</td> + <td>0.60 ± 0.17</td> + <td>0.60 ± 0.10</td> + <td>0.61 ± 0.13</td> + </tr> + <tr> + <td>concrete (3%)</td> + <td><strong>0.46 ± 0.09</strong></td> + <td>0.57 ± 0.11</td> + <td>0.58 ± 0.14</td> + <td>0.59 ± 0.10</td> + <td>0.62 ± 0.10</td> + </tr> + <tr> + <td>concrete (4%)</td> + <td><strong>0.46 ± 0.12</strong></td> + <td>0.58 ± 0.12</td> + <td>0.53 ± 0.14</td> + <td>0.56 ± 0.12</td> + <td>0.61 ± 0.11</td> + </tr> + <tr> + <td>concrete (5%)</td> + <td><strong>0.49 ± 0.11</strong></td> + <td>0.59 ± 0.12</td> + <td>0.55 ± 0.13</td> + <td>0.56 ± 0.09</td> + <td>0.62 ± 0.10</td> + </tr> + <tr> + <td>concrete (6%)</td> + <td><strong>0.48 ± 0.08</strong></td> + <td>0.53 ± 0.09</td> + <td>0.53 ± 0.10</td> + <td>0.53 ± 0.08</td> + <td>0.59 ± 0.11</td> + </tr> + <tr> + <td>concrete (7%)</td> + <td><strong>0.47 ± 0.07</strong></td> + <td>0.52 ± 0.10</td> + <td>0.50 ± 0.09</td> + <td>0.51 ± 0.08</td> + <td>0.58 ± 0.09</td> + </tr> + <tr> + <td>concrete (8%)</td> + <td><strong>0.45 ± 0.07</strong></td> + <td>0.53 ± 0.09</td> + <td>0.47 ± 0.09</td> + <td>0.48 ± 0.06</td> + <td>0.55 ± 0.08</td> + </tr> + <tr> + <td>concrete (9%)</td> + <td><strong>0.43 ± 0.06</strong></td> + <td>0.47 ± 0.07</td> + <td>0.47 ± 0.07</td> + <td>0.47 ± 0.05</td> + <td>0.54 ± 0.07</td> + </tr> + <tr> + <td>crimepredict (2%)</td> + <td><strong>0.15 ± 0.02</strong></td> + <td>0.18 ± 0.03</td> + <td>0.15 ± 0.03</td> + <td>0.16 ± 0.02</td> + <td>0.15 ± 0.02</td> + </tr> + <tr> + <td>crimepredict (3%)</td> + <td><strong>0.15 ± 0.03</strong></td> + <td>0.17 ± 0.03</td> + <td>0.15 ± 0.03</td> + <td>0.16 ± 0.04</td> + <td>0.15 ± 0.02</td> + </tr> + <tr> + <td>crimepredict (4%)</td> + <td><strong>0.14 ± 0.02</strong></td> + <td>0.16 ± 0.02</td> + <td>0.14 ± 0.02</td> + <td>0.16 ± 0.03</td> + <td>0.14 ± 0.01</td> + </tr> + <tr> + <td>crimepredict (5%)</td> + <td><strong>0.14 ± 0.02</strong></td> + <td>0.17 ± 0.02</td> + <td>0.15 ± 0.02</td> + <td>0.17 ± 0.02</td> + <td>0.15 ± 0.02</td> + </tr> + <tr> + <td>crimepredict (6%)</td> + <td><strong>0.15 ± 0.01</strong></td> + <td>0.17 ± 0.01</td> + <td>0.15 ± 0.01</td> + <td>0.17 ± 0.02</td> + <td>0.15 ± 0.01</td> + </tr> + <tr> + <td>crimepredict (7%)</td> + <td><strong>0.14 ± 0.01</strong></td> + <td>0.17 ± 0.01</td> + <td>0.15 ± 0.01</td> + <td>0.17 ± 0.02</td> + <td>0.15 ± 0.01</td> + </tr> + <tr> + <td>crimepredict (8%)</td> + <td><strong>0.14 ± 0.01</strong></td> + <td>0.17 ± 0.01</td> + <td>0.14 ± 0.01</td> + <td>0.16 ± 0.02</td> + <td>0.14 ± 0.00</td> + </tr> + <tr> + <td>crimepredict (9%)</td> + <td><strong>0.14 ± 0.01</strong></td> + <td>0.16 ± 0.01</td> + <td>0.14 ± 0.01</td> + <td>0.16 ± 0.02</td> + <td>0.14 ± 0.01</td> + </tr> + </tbody> + </table> + <p> + L'approche <emph>LapS3L</emph> donne de meilleurs résultats sur + les jeux de données <emph>behavior</emph>, <emph>concrete</emph> + et <emph>crimepredict</emph>. Seul le jeu de + données <emph>airfoil</emph> est partagé + entre <emph>LapS3L</emph> et <emph>LapRLS</emph>. Notons que le + jeu de données <emph>behavior</emph>, qui comporte un très + faible nombre d'individus, ne permet pas d'obtenir suffisamment + de vecteurs supports pour le ν-SVR en ne conservant que 2% des + labels, et ne permet pas à l'algorithme <emph>SSSL</emph> de + trouver une solution, puisque la matrice de covariance est + toujours trop faible. + </p> + <h2>Application aux données de réseau d’assainissement</h2> + <p> + Dans cette section, nous utilisons un jeu de données dont le but + est la reconstitution de l'âge des canalisations des réseaux + d'assainissement de la ville de Lyon. L'inspection des + canalisations est une tâche complexe, et étant donné le faible + nombre de canalisations inspectées chaque année, il est + nécessaire de privilégier l'inspection des canalisations les + plus dégradées. + </p> + <p> + Pour savoir quelles canalisations sont dégradées, il est + nécessaire d'en connaître la date de pose + <h:cite href="davies2001factors,ahmadi_2014_influence,harvey2014predicting"/>, + qui indique l'âge et les techniques employées (celles-ci ont + évolué au cours du dernier siècle). + </p> + <p> + Parmi les 85766 canalisations recensées, 24% seulement ont une + date de pose connue. Le jeu de données est composé de 4 + variables catégorielles (forme, matériau, type d'effluent, et si + la canalisation fait partie du réseau structurant), et 3 + variables continues (largeur, hauteur, longueur). + </p> + <h3>Pré-traitement des données</h3> + <p> + D'après les registres de pose, il y a toujours eu chaque année + une quantité comparable de canalisations posées, si l'on exclut + les périodes de guerre. En revanche, les informations + historiques qui nous sont parvenues ne nous permettent de + connaître principalement que les dates de pose des canalisations + récentes (voir figure <h:ref href="#fig-hireaugramme" />). Le + réseau ne s'est pas construit uniquement à partir de 1975 ; les + dates de pose des canalisations anciennes (qui sont l'objectif + principal de l'application) sont majoritairement inconnues. + </p> + <figure> + <img src="images/hireaugramme.png" /> + <figcaption id="fig-hireaugramme"> + Histogramme montrant la répartition des dates de pose des + canalisations connues. + </figcaption> + </figure> + <p> + En effectuant un apprentissage sur ces données, les + canalisations anciennes sont majoritairement ignorées ou + considérées comme des observations anormales. Or, ce sont + précisément ces canalisations dont on veut connaître la date de + pose. + </p> + <p> + Nous avons donc ré-échantillonné le jeu de données, afin de + sélectionner 2000 conduites dont la date de pose suit une loi + uniforme (en sachant qu'il existe des périodes entières pendant + lesquelles aucune canalisation n'est connue ; la canalisation + est donc tirée au bord de ces périodes), et 2000 canalisations + parmi tout l'ensemble de données pour le jeu de données non + labellisé. + </p> + <h3>Résultats</h3> + <p> + La métrique évaluée est la RMSE. Les trois algorithmes comparés + sont <emph>LapS3L</emph>, <emph>SSSL</emph> + et <emph>LapRLS</emph> (non-linéaire). L'erreur de régression en + année est donnée par la table <h:ref href="#tbl-hireau"/>. Notre + approche donne une erreur de régression plus faible. + </p> + <table latex-align="ccc"> + <caption id="tbl-hireau"> + Métrique RMSE pour le jeu de données d'assainissement en + années pour + <emph>LapS3L</emph>, + <emph>SSSL</emph>, + <emph>LapRLS</emph> + </caption> + <thead> + <tr> + <th><strong>LapS3L</strong></th> + <th><emph>SSSL</emph></th> + <th><emph>LapRLS</emph></th> + </tr> + </thead> + <tbody> + <tr> + <td>8.69</td> + <td>10.03</td> + <td>13.70</td> + </tr> + </tbody> + </table> + <p> + L'évolution de la performance de l'algorithme en fonction du + nombre de composantes <h:eq>s</h:eq> (figure + <h:ref href="#fig-hireau-s"/>) montre qu'il est nécessaire de + conserver un grand nombre de composantes pour un bon + fonctionnement de l'algorithme. C'est un avantage + de <emph>LapS3L</emph>, puisque lorsque le nombre de composantes + extraites est supérieur au rang de la matrice de covariance, + <emph>SSSL</emph> ne donne pas de solution, alors que la + régularisation effectuée par <emph>LapS3L</emph> le permet. + </p> + <p> + L'erreur de régression de <emph>LapRLS</emph> est une constante, + puisqu'elle ne dépend pas du nombre de composantes. L'erreur de + régression pour <emph>SSSL</emph> diminue jusqu'à atteindre son + minimum pour 100 composantes principales, puis elle monte très + abruptement. L'erreur de régression de <emph>LapS3L</emph> suit + celle de <emph>SSSL</emph>, remonte moins abruptement entre 100 + et 200 composantes, puis baisse à nouveau jusqu'à 2000 + composantes, en atteignant le minimum pour les trois + algorithmes, après quoi elle augmente elle aussi très + abruptement. + </p> + <figure> + <img src="images/hireau-s.png" /> + <figcaption id="fig-hireau-s"> + Évolution de la performance + de <emph>LapS3L</emph>, <emph>SSSL</emph>, + et <emph>LapRLS</emph>, en fonction du nombre de composantes + sélectionnées (en échelle logarithmique) + </figcaption> + </figure> + <h2>Conclusion</h2> + <p> + Nous avons proposé un algorithme de régression semi-supervisé, + <emph>LapS3L</emph>, comme une extension stricte de + l'algorithme <emph>SSSL</emph>. Par conséquent, au prix + d'un <emph>tuning</emph> plus précis, <emph>LapS3L</emph> a + donné de meilleures performances que son concurrent. Nous avons + montré expérimentalement que pour un tuning de même complexité + pour <emph>SSSL</emph> et <emph>LapS3L</emph>, <emph>LapS3L</emph> + donne une plus faible erreur de régression sur les deux jeux de + données publics utilisés dans l'article d'origine + de <emph>SSSL</emph>. Nous avons montré également que + <emph>LapS3L</emph> est compétitif sur d'autres jeux de données + de régression. Enfin, nous avons montré expérimentalement + l'importance de la régularisation employée dans un cas + d'application réelle. + </p> + <h1 short="LSMR">Régression semi-supervisée multi-labels : une approche régularisée</h1> + <h:résumé-chapitre> + <p> + Dans ce chapitre, nous reprenons le travail décrit dans le + chapitre précédent, pour l'étendre dans le cadre de + l'apprentissage multi-labels. Nous menons également une étude + expérimentale détaillée sur des jeux de données publics + spécifiques. + </p> + <p> + L'idée de cette extension consiste à modifier la + régularisation employée. En effet, il est possible d'employer + des régularisations multi-labels, or la régularisation + employée pour <emph>LapS3L</emph> ne l'est pas. + </p> + </h:résumé-chapitre> + <h2>Introduction</h2> + <p> + L'un des défis principaux de l'apprentissage automatique moderne + consiste à apprendre à partir de données labellisées à la main + ainsi que de données non labellisées, qui sont généralement plus + faciles à obtenir. L'apprentissage faiblement labellisé + <h:cite href="li_convex_2013"/>, et plus particulièrement + l'apprentissage semi-supervisé + <h:cite href="chapelle_semi-supervised_2006,zhu_semi-supervised_nodate"/>, + abordent ce défi en utilisant soit des approches de propagation + de labels pour suppléer des méthodes supervisées + <h:cite href="zhu_semi-supervised_nodate,zhao_learning_2015"/>, + ou utilisent l'information des labels comme contraintes pour des + méthodes non supervisées + <h:cite href="basu_constrained_2009,zhang2012trace"/>. + </p> + <p> + De nombreuses méthodes semi-supervisées fondées sur des méthodes + supervisées ont été proposées. Par exemple, on retrouve des + adaptations telles que le <emph>self-training</emph> + <h:cite href="selftraining"/> ou <emph>co-training</emph> + <h:cite href="blum_combining_1998,zhou_semi-supervised_2005"/>, + des cas d'apprentissage <emph>transductif</emph> + <h:cite href="joachims1999transductive,bennett1999semi"/>, ou + des méthodes génératives <h:cite href="nigam2000text"/>. + </p> + <p> + Dans le cas particulier de la régression, avec une prédiction + numérique, des applications spécifiques sont proposées + <h:cite href="azriel_semi-supervised_2016,ryan_semi-supervised_2015"/>, + et on retrouve principalement des approches fondées sur + l'apprentissage de représentation de l'espace + <h:cite href="ji_simple_2012"/> ou utilisant un graphe entre + individus tenant compte de la similarité + <h:cite href="moscovich_minimax-optimal_nodate"/>, avec une + insistance particulière sur la régularisation Laplacienne + <h:cite href="cai_semi-supervised_2006,belkin_manifold_2006"/>. + </p> + <p> + De plus, l'apprentissage multi-labels vise à exploiter les + relations entre <emph>labels</emph> pour apporter plus + d'information à la tâche d'apprentissage. Des travaux théoriques + ont été proposés <h:cite href="gasse_optimality_2015"/>, et de + nombreuses méthodes multi-labels ont été proposées + <h:cite href="borchani_survey_2015,spyromitros_xioufis_multi_target_2016"/>. Certaines + stratégies transforment un problème multi-labels en plusieurs + problèmes mono-label + <h:cite href="read2011classifier,liu_easy--hard_2017"/>, et il + est parfois possible d'étendre directement le problème au cadre + multi-labels, comme pour les processus gaussiens + <h:cite href="yu_learning_2005" />. + </p> + <p> + De nombreux algorithmes d'apprentissage multi-labels minimisent + une fonction objectif régularisée. Ce peut être avec une + régularisation non-convexe <h:cite href="msmtfl,l21m2"/>, mais + les approches convexes sont plus fréquentes, avec l'adaptation + de l'algorithme LASSO <h:cite href="tibshirani1996regression"/> + au cadre multi-labels + <h:cite href="argyriou_multitask_nodate,mifs"/>, ou le + <emph>Clustered Multik-Task Learning</emph> + <h:cite href="cmtl"/>, ou d'autres approches d'apprentissage de + représentation de l'espace des labels + <h:cite href="chen_feature-aware_2012,luo_adaptive_2017"/>. + </p> + <p> + Pour l'apprentissage de régression, les méthodes spécifiques + sont plus rares. Il est d'usage de modifier la fonction objectif + pour utiliser des labels à valeurs réelles + <h:cite href="malsar"/>. + </p> + <h2>Travaux liés</h2> + <p> + Pour l'apprentissage de régression mono-label, nous avons + démontré l'intérêt d'utiliser une version régularisée de + l'algorithme <emph>SSSL</emph> <h:cite href="ji_simple_2012"/> + grâce à la régularisation Laplacienne. La caractéristique + principale de cette famille d'algorithmes réside dans leur + fonctionnement en deux étapes, qui permettent dans un premier + temps de faire un changement d'espace <emph>non-supervisé</emph> + propice à l'apprentissage de régression de certains jeux de + données, puis d'adopter une <emph>régression linéaire</emph> + dans ce nouvel espace. + </p> + <p> + Pour rappel, l'utilisation de la régularisation Laplacienne dans + le nouvel espace permet de lier les deux espaces de description + des individus, dans le but de satisfaire l'hypothèse suivante : + </p> + <blockquote> + Si deux individus sont proches dans l'espace réel, alors l'écart + de prédiction doit être faible. + </blockquote> + <p> + Nous avons montré expérimentalement que la complexité + supplémentaire due à l'introduction de cette régularisation ne + nécessite pas de procédure de tuning plus complexe. + </p> + <p> + Comme évoqué ci-dessus, il est aussi possible d'utiliser la + régression Laplacienne pour traiter le problème d'apprentissage + multi-labels <h:cite href="malsar"/>. Dans cette approche, on + construit un graphe des labels, et il s'agit de régulariser le + modèle de façon à introduire l'hypothèse suivante : + </p> + <blockquote> + Si deux labels sont similaires, les valeurs du modèle pour ces + deux labels doivent être similaires. + </blockquote> + <h2>Approche proposée : <emph>LSMR</emph></h2> + <h3>Notations</h3> + <p> + Les individus sont décrits dans l'espace des variables supposé + être de + dimension <h:eq>d</h:eq>, <h:eq>\mathbb{R}^{d}</h:eq>. L'ensemble + des labels est de dimension <h:eq>m</h:eq>. Étant donné que le + problème est celui de la régression, cet espace est décrit + dans <h:eq>\mathbb{R}^{m}</h:eq>. + </p> + <p> + Notons <h:eq>\mathcal{V} \in \mathbb{R}^{N, d}</h:eq> la matrice + de données, dont les lignes correspondent aux individus. On note + <h:eq>n_l</h:eq> le nombre d'individus labellisés au total. + </p> + <p> + Associée à cette matrice de données, la matrice de labels de + régression <h:eq>Y \in \mathbb{R}^{N, m}</h:eq> contient une + ligne par individu ; seules les lignes correspondant aux + individus labellisés sont renseignées. On suppose que tous les + labels sont manquants simultanément : si un individu est + labellisé, les valeurs de tous les labels sont + renseignés. Sinon, aucune valeur n'est renseignée. + </p> + <h3>Première étape : changement d’espace</h3> + <p> + Comme pour l'algorithme <emph>SSSL</emph> + et <emph>LapS3L</emph>, une première étape consiste à choisir + une fonction noyau symétrique, <h:eq>\kappa \colon \mathbb{R}^d + \times \mathbb{R}^d \to \mathbb{R}</h:eq>, et à construire la + matrice noyau entre tous les individus de l'ensemble + d'apprentissage : + </p> + <h:equation> + \forall i, j \in \{1, ..., N\}, \quad K_{i, j} = \kappa (\mathcal{V}_{i, .}, \mathcal{V}_{j, .}) + </h:equation> + <p> + <h:eq>K</h:eq> étant une matrice symétrique réelle, on peut en + extraire les <h:eq>s</h:eq> valeurs propres réelles les plus + élevées, pour <h:eq>s \leq N</h:eq>, et les vecteurs propres + associés. Ces derniers forment une matrice <h:eq>U \in + \mathbb{R}^{N,s}</h:eq>, dont les colonnes sont de norme + unitaire, où chaque ligne correspond à un individu de l'ensemble + d'apprentissage. Étant donné que l'on n'utilise pas la matrice + de labels, cette première étape est non supervisée. + </p> + <p> + Le changement d'espace s'obtient en posant : + </p> + <h:equation> + X \gets K U + </h:equation> + <p> + La matrice <h:eq>X</h:eq> comprend donc une ligne par individu, + et nous pouvons en extraire la sous-matrice correspondant aux + individus labellisés comme <h:eq>X_l \in \mathbb{R}^{n, + s}</h:eq>. + </p> + <h3>Régularisation semi-supervisée multi-labels</h3> + <p> + En reprenant l'algorithme <emph>LapS3L</emph>, la régression + semi-supervisée qui définit la seconde étape de l'algorithme + utilise deux termes de régularisation : + </p> + <ul> + <li>une régularisation <emph>Laplacienne</emph>,</li> + <li>une régularisation <emph>Ridge</emph>, qui pénalise la + complexité du modèle.</li> + </ul> + <p> + Nous proposons de remplacer le terme de + régularisation <emph>Ridge</emph> en régularisation Laplacienne + multi-labels. Ainsi, en définissant le graphe des labels par la + matrice d'adjacence <h:eq>M_m \in \mathbb{R}^{m, m}</h:eq>, et + le graphe des individus par la matrice d'adjacence <h:eq>M_s \in + \mathbb{R}^{N, N}</h:eq>, le terme à pénaliser devient : + </p> + <h:mini id="lsmr-regu"> + <h:variables>W \in \mathbb{R}^{d, m}</h:variables> + <h:objective> + \left\|X_l W - Y_l\right\|_F^2 + \alpha \mathrm{tr} (W'X'L_sXW) + \beta \mathrm{tr} (W L_m W') + </h:objective> + </h:mini> + <p> + où : + </p> + <ul> + <li> + <h:eq>\alpha</h:eq> est le régulariseur semi-supervisé ; + </li> + <li> + <h:eq>\beta</h:eq> est le régulariseur multi-labels ; + </li> + <li> + <h:eq>L_s</h:eq> est la matrice Laplacienne du graphe des + individus, + + <h:equation-x>L_s = D_s - M_s</h:equation-x> + + avec <h:eq>D_s</h:eq> la matrice de degré du graphe des + individus, + + <h:equation-x> + \forall i \in \{1, ..., N\}, \quad {D_s} (i, i) = \sum_{j = 1}^N {M_s} (i, j) + </h:equation-x> + </li> + <li> + <h:eq>L_m</h:eq> est la matrice Laplacienne du graphe des labels, + + <h:equation-x>L_m = D_m - M_m</h:equation-x> + + avec <h:eq>D_m</h:eq> la matrice de degré du graphe des labels, + + <h:equation-x> + \forall k \in \{1, ..., m\}, \quad {D_m} (k, k) = \sum_{l = 1}^m {M_m} (k, l) + </h:equation-x> + </li> + </ul> + <p> + La pénalisation est rendue explicite sur des exemples figure + <h:ref href="#fig-bothsemimulti"/>. En haut, le graphe est + construit à partir de 4 individus ; la proximité dans l'espace + des variables est indiquée par une arête. En bas, le graphe est + construit à partir de 3 labels ; une arête relie deux labels + ayant souvent des valeurs similaires sur beaucoup + d'individus. Pour l'apprentissage semi-supervisé, en haut, les + labels sont considérés de manière indépendante. On note à + l'intérieur du cercle la valeur prédite par le modèle pour un + label. Pour l'apprentissage multi-labels, en bas, chaque label a + un modèle linéaire, dont les poids sont représentés sur une + colonne. La valeur de chaque poids du modèle est représentée par + une couleur différente. Dans la partie gauche de la figure, la + pénalisation est faible, puisque le modèle donne des valeurs + similaires aux individus liés (en haut) et les modèles sont + similaires pour des labels reliés (en bas). À droite, la + pénalisation est plus forte. + </p> + <figure> + <img src="images/bothsemimulti.svg" /> + <figcaption id="fig-bothsemimulti"> + Exemples de pénalisation pour l'apprentissage semi-supervisé + (en haut) et l'apprentissage multi-labels (en bas) + </figcaption> + </figure> + <p> + Dans la suite, nous appellerons la modification + proposée <emph>LSMR</emph>, pour <emph>Laplacian-regularized + Simple algorithm for Semi-supervised multi-labels + Regression</emph>. La modification proposée de l'algorithme + <emph>LapS3L</emph> consiste toujours en une extension de + l'algorithme <emph>SSSL</emph>, mais sa différence + avec <emph>LapS3L</emph> réside dans un autre choix pour la + régularisation Ridge. + </p> + <h2>Algorithme d’optimisation</h2> + <p> + La fonction objectif employée dans + l'algorithme <emph>LapS3L</emph> admet une solution analytique, + qui permet d'obtenir la valeur du modèle <h:eq>W</h:eq> grâce à + une résolution d'un système linéaire de dimension <h:eq>s \times + s</h:eq>. Malheureusement, on ne peut pas l'appliquer + directement pour <emph>LSMR</emph>, à moins d'avoir à résoudre + <h:eq>m^2</h:eq> systèmes linéaire distincts. Cette limitation + est commune à beaucoup de méthodes de régularisation + multi-labels, ce qui pousse les méthodes de MALSAR à adopter une + méthode d'optimisation différente. + </p> + <h3>Descente de gradient</h3> + <p> + La fonction objectif obtenue dans <h:ref href="#lsmr-regu"/> + présente les caractéristiques suivantes : + </p> + <ul> + <li> + la variable d'optimisation, <h:eq>W</h:eq>, est réelle ; + </li> + <li> + la fonction objectif est convexe, si les arêtes des matrices + d'adjacence des graphes des individus et des labels sont à + poids positifs ; + </li> + <li>la fonction objectif est lisse.</li> + </ul> + <p> + Par conséquent, le problème peut être résolu par descente de + gradient, dont le calcul est donné par + <h:eqref href="#lsmr-gradient"/>. + </p> + <h:equation id="lsmr-gradient"> + 2 \left[X_l' X_l + \alpha X' L_s X\right] W - 2 X_l' Y_l + 2 \beta W L_m + </h:equation> + <h3>Pas d’apprentissage</h3> + <p> + L'algorithme de descente du gradient produit des itérations de + descente de l'erreur d'apprentissage jusqu'à convergence de la + variable d'optimisation. Chaque itération consiste à calculer la + valeur du gradient au point donné pour la valeur courante de la + variable d'optimisation, <h:eq>\nabla_W</h:eq> (selon + <h:eqref href="#lsmr-gradient"/>), puis poser : + </p> + <h:equation> + W \gets W - \eta \nabla_W + </h:equation> + <p> + où <h:eq>\eta</h:eq> est le <emph>pas d'apprentissage</emph>. + Dans notre cas, le gradient <h:ref href="#lsmr-gradient"/> est + une fonction Lipschitzienne : pour deux valeurs quelconques du + modèle, <h:eq>P, Q \in \mathbb{R}^{s, m}</h:eq>, + </p> + <h:equation> + \left\|\nabla_W (P) - \nabla_W (Q)\right\|_F^2 \leq C \left\|P - Q\right\|_F^2 + </h:equation> + <p> + avec : + </p> + <h:equation> + C = 2 \left(\rho \left(X_l' X_l + \alpha X'L_sX\right) + \beta \rho (L_m)\right) + </h:equation> + <p> + Pour toute matrice <h:eq>M</h:eq> symétrique réelle, <h:eq>\rho + (M)</h:eq> désigne le rayon spectral de <h:eq>M</h:eq>, + c'est-à-dire sa plus grande valeur propre. En posant : + </p> + <h:equation> + \eta \gets \frac 1 C + </h:equation> + <p> + La convergence de l'algorithme de descente de gradient est + assurée <h:cite href="agd" />. + </p> + <h3>Initialisation du modèle</h3> + <p> + Le modèle <h:eq>W \in \mathbb{R}^{s, m}</h:eq> est initialisé + comme la solution du problème de régression linéaire, avec un + terme de régularisation Ridge utilisant une valeur de + régulariseur faible. + </p> + <h:equation> + W \gets \left[X_l' X_l + \epsilon I_s\right]^{-1} X_l' Y_l + </h:equation> + <p> + avec <h:eq>\epsilon</h:eq> faible (pour l'implémentation, nous + avons retenu <h:eq>\epsilon = 10^{-6}</h:eq>), et <h:eq>I_s \in + \mathbb{R}^{s, s}</h:eq> la matrice identité en + dimension <h:eq>s</h:eq>. + </p> + <h3>Descente de gradient accélérée</h3> + <p> + L'algorithme de descente de gradient accélérée + <h:cite href="agd"/> est une amélioration de l'algorithme de + descente de gradient originale qui propose une convergence plus + rapide. Pour notre application, l'algorithme d'optimisation est + résumé dans l'algorithme + <h:ref href="#algorithme-lsmr-train"/>. La prédiction s'effectue + ainsi avec l'algorithme + <h:ref href="#algorithme-lsmr-predict"/>, qui est simplement la + version multi-labels de l'algorithme de prédiction de + l’algorithme <emph>LapS3L</emph> développé dans le chapitre + précédent, en remplaçant le modèle de dimension <h:eq>s</h:eq> + par un modèle de dimension <h:eq>s \times m</h:eq>. + </p> + <h:algorithm id="algorithme-lsmr-train"> + <alg:algorithmic> + <alg:donnée><h:eq>\mathcal{V} \in \mathbb{R}^{N, d}</h:eq></alg:donnée> + <alg:donnée><h:eq>Y \in \mathbb{R}^{n_l, m}</h:eq></alg:donnée> + <alg:hyperparamètre><h:eq>s \in \{1, ..., N\}</h:eq></alg:hyperparamètre> + <alg:hyperparamètre><h:eq>\kappa \colon \mathcal{X} \times \mathcal{X} \to \mathbb{R}</h:eq></alg:hyperparamètre> + <alg:hyperparamètre>matrice Laplacienne du graphe des individus, <h:eq>L_s \in \mathbb{R}^{N, N}</h:eq></alg:hyperparamètre> + <alg:hyperparamètre>matrice Laplacienne du graphe des labels, <h:eq>L_m \in \mathbb{R}^{m, m}</h:eq></alg:hyperparamètre> + <alg:hyperparamètre><h:eq>\alpha > 0</h:eq></alg:hyperparamètre> + <alg:hyperparamètre><h:eq>\beta > 0</h:eq></alg:hyperparamètre> + <alg:state> + Construire la matrice <h:eq>K \in \mathbb{R}^{N, + N}</h:eq> : <h:equation-x>\forall i, j, \quad K_{i, j} = + \kappa (\mathcal{V}_{i, .}, \mathcal{V}_{j, + .})</h:equation-x> + </alg:state> + <alg:state> + Décomposer la matrice <h:eq>K</h:eq> en valeurs propres et + vecteurs propres, sélectionner les <h:eq>s</h:eq> vecteurs + propres ayant la plus grande valeur propre + associée : <h:eq>U \in \mathbb{R}^{N, s}</h:eq> + </alg:state> + <alg:state> + Poser <h:eq>X := K U</h:eq> + </alg:state> + <alg:state> + Sélectionner la sous-matrice <h:eq>Xl \in + \mathbb{R}^{n,s}</h:eq> composée des lignes + de <h:eq>X</h:eq> correspondant aux individus labellisés + </alg:state> + <alg:state> + Appliquer l’algorithme de descente de gradient accélérée, en + utilisant les paramètres suivants : + <alg:state> + Pas d'apprentissage : <h:eq>\frac 1 C</h:eq>, <h:eq>C = 2 + \left(\rho \left(X_l' X_l + \alpha X'L_sX\right) + \beta + \rho (L_m)\right)</h:eq> + </alg:state> + <alg:state> + Modèle initial : <h:eq>W \in \mathbb{R}^{s, m} = + \left[X_l' X_l + \epsilon I_s\right]^{-1} X_l' Y_l</h:eq> + </alg:state> + <alg:state> + Calcul du gradient : <h:eq>\nabla_W \gets 2 \left[X_l' X_l + + \alpha X' L_s X\right] W - 2 X_l' Y_l + 2 \beta W + L_m</h:eq> + </alg:state> + </alg:state> + <alg:résultat><h:eq>U \in \mathbb{R}^{N, s}</h:eq></alg:résultat> + <alg:résultat><h:eq>W \in \mathbb{R}^{s, m}</h:eq></alg:résultat> + </alg:algorithmic> + <figcaption> + Algorithme <emph>LSMR</emph> : apprentissage + </figcaption> + </h:algorithm> + <h:algorithm id="algorithme-lsmr-predict"> + <alg:algorithmic> + <alg:donnée><h:eq>\mathcal{V} \in \mathbb{R}^{N, d}</h:eq>, <h:eq>\mathcal{V}_t \in \mathbb{R}^{n_t, d}</h:eq></alg:donnée> + <alg:hyperparamètre><h:eq>\kappa \colon \mathcal{X} \times \mathcal{X} \to \mathbb{R}</h:eq></alg:hyperparamètre> + <alg:modèle><h:eq>U \in \mathbb{R}^{N, s}</h:eq></alg:modèle> + <alg:modèle><h:eq>W \in \mathbb{R}^{s, m}</h:eq></alg:modèle> + <alg:state> + Construire la matrice <h:eq>K_b \in \mathbb{R}^{N, + n_t}</h:eq> : + + <h:equation-x> + \forall i, j, \quad {K_b}_{i, j} = \kappa (\mathcal{V}_{i, .}, {\mathcal{V}_t}_{j, .}) + </h:equation-x> + </alg:state> + <alg:state> + Poser <h:eq>X_t := K_b' U</h:eq> + </alg:state> + <alg:résultat><h:eq>\hat Y \gets X_t W</h:eq></alg:résultat> + </alg:algorithmic> + <figcaption> + Algorithme <emph>LSMR</emph> : prédiction + </figcaption> + </h:algorithm> + <h2>Étude comparative</h2> + <p> + Afin de s'assurer de la performance de notre approche, nous + proposons deux études expérimentales. Tout d'abord, puisqu'elle + généralise une approche existante, nous devons nous assurer que + cette extension est nécessaire. Puis nous montrerons quelques + comparaisons avec d'autres régularisations pour de la régression + multi-labels. + </p> + <h3>Jeux de données utilisés</h3> + <p> + Nous avons utilisé des jeux de données du projet MULAN + <h:fn> + <a href="http://mulan.sourceforge.net/datasets-mtr.html"> + http://mulan.sourceforge.net/datasets-mtr.html + </a> + </h:fn>, décrits dans + <h:cite href="spyromitros_xioufis_multi_target_2016"/>, à quoi + nous avons ajouté un échantillon de 1000 individus du jeu de + données SARCOS <h:cite href="sarcos"/>. Nous n'avons pas + conservé tous les jeux de données, les plus grands contenant + trop d'individus pour appliquer directement l'algorithme + LSMR. Les jeux de données et leur caractéristiques sont résumés + dans la table <h:ref href="#tbl-lsmr-datasets"/>. + </p> + <table latex-align="|l|cccc|"> + <caption id="tbl-lsmr-datasets"> + Jeux de données utilisés pour l'étude expérimentale de notre + approche, <strong>LSMR</strong> + </caption> + <thead> + <tr> + <th><strong>Jeu de données</strong></th> + <th><strong>Nb. indiv. (avec label + sans)</strong></th> + <th><strong>Test</strong></th> + <th><strong>Variables</strong></th> + <th><strong>Labels</strong></th> + </tr> + </thead> + <tbody> + <tr> + <td><emph>atp1d</emph></td> + <td>262 (76 + 186)</td> + <td>165</td> + <td>411</td> + <td>6</td> + </tr> + <tr> + <td><emph>atp7d</emph></td> + <td>234 (67 + 167)</td> + <td>147</td> + <td>411</td> + <td>6</td> + </tr> + <tr> + <td><emph>edm</emph></td> + <td>121 (35 + 86)</td> + <td>73</td> + <td>16</td> + <td>2</td> + </tr> + <tr> + <td><emph>enb</emph></td> + <td>601 (173 + 428)</td> + <td>366</td> + <td>8</td> + <td>2</td> + </tr> + <tr> + <td><emph>jura</emph></td> + <td>281 (81 + 200)</td> + <td>173</td> + <td>15</td> + <td>3</td> + </tr> + <tr> + <td><emph>oes10</emph></td> + <td>314 (91 + 223)</td> + <td>198</td> + <td>298</td> + <td>16</td> + </tr> + <tr> + <td><emph>oes97</emph></td> + <td>257 (75 + 182)</td> + <td>163</td> + <td>263</td> + <td>16</td> + </tr> + <tr> + <td><emph>osales</emph></td> + <td>495 (144 + 351)</td> + <td>309</td> + <td>401</td> + <td>12</td> + </tr> + <tr> + <td><emph>sarcossub</emph></td> + <td>779 (225 + 554)</td> + <td>467</td> + <td>21</td> + <td>7</td> + </tr> + <tr> + <td><emph>scpf</emph></td> + <td>889 (256 + 633)</td> + <td>521</td> + <td>23</td> + <td>3</td> + </tr> + <tr> + <td><emph>sf1</emph></td> + <td>250 (73 + 177)</td> + <td>158</td> + <td>31</td> + <td>3</td> + </tr> + <tr> + <td><emph>sf2</emph></td> + <td>832 (240 + 592)</td> + <td>501</td> + <td>31</td> + <td>3</td> + </tr> + <tr> + <td><emph>wq</emph></td> + <td>827 (238 + 589)</td> + <td>487</td> + <td>16</td> + <td>14</td> + </tr> + </tbody> + </table> + <p> + Nous avons divisé les jeux de données en une partie pour + l'apprentissage et une partie pour le test. Ces jeux de données + étant labellisés, nous avons sélectionné 30% des individus de + l'ensemble d'apprentissage pour en supprimer les labels, pour + tous les labels simultanément. Le nombre de labels enlevé est + bas, surtout comparé au travail effectué + pour <emph>LapS3L</emph>. Cependant le nombre d'individus total + étant relativement faible, il n'est pas possible d'en enlever + davantage. + </p> + <p> + Nous avons centré et réduit toutes les variables, et tous les + labels, en soustrayant la moyenne et divisant par + l'écart-type. Ceci garantit que l'on peut appliquer à la fois + une fonction noyau entre les individus à partir des variables, + et à la fois une fonction noyau entre les labels à partir des + données labellisées. D'autre part, si les valeurs de l'un des + labels sont négligeables devant les valeurs d'un autre, le + calcul des métriques multi-labels risque de ne pas montrer la + pertinence des algorithmes en tant qu'algorithmes multi-labels. + </p> + <h3>Protocole expérimental</h3> + <p> + La procédure de tuning consiste à tirer une valeur pour chaque + hyperparamètre, selon la recherche aléatoire + <h:cite href="randomsearch"/>. Cette méthode permet d'éviter + l'écueil de la <emph>recherche de grille</emph>, qui considère + tous les hyperparamètres comme équitablement importants. Dans le + cas où l'algorithme présente de nombreux hyperparamètres, comme + par exemple <strong>LSMR</strong>, la recherche aléatoire est à + préférer. + </p> + <p> + Les hyperparamètres donnant la meilleure métrique aRMSE en + validation croisée à 10 <emph>folds</emph> sont retenus. Pour + rappel, la métrique aRMSE est définie par : + </p> + <h:equation> + \mathrm{aRMSE} = \frac 1 m \sum_{k = 1}^m \sqrt{\frac {\left\|Y - \hat Y\right\|_F^2} {n_t}} + </h:equation> + <p> + <h:eq>\hat Y</h:eq> désignant la prédiction sur le jeu de + test, <h:eq>Y</h:eq> les vrais labels du jeu de test, + et <h:eq>n_t</h:eq> le nombre d'individu du jeu de test. + </p> + <p> + La métrique doit être minimisée. Puisque l'on a normalisé les + labels individuellements, si les labels du jeu de test suivent + exactement la même distribution que le jeu d'apprentissage, la + métrique est égale à 1 en prédisant toujours 0. + </p> + <p> + La validation croisée en 10 <emph>folds</emph> consiste à + partitionner les données labellisées de l'ensemble + d'apprentissage en 10 échantillons. L'apprentissage se fait sur + 9 échantillons, plus toutes les données non labellisées. Le test + se fait sur l'échantillon restant, en calculant la métrique + aRMSE. En répétant l'opération sur les 10 échantillons pour le + test, la métrique aRMSE moyenne est calculée. + </p> + <p> + Notre approche utilise 4 hyperparamètres de différentes + natures : + </p> + <ol> + <li>La fonction noyau, <h:eq>\kappa</h:eq> ;</li> + <li>Le nombre de composantes principales, <h:eq>s</h:eq> ;</li> + <li>Le régulariseur semi-supervisé, <h:eq>\alpha</h:eq> ;</li> + <li>Le régulariseur multi-labels, <h:eq>\beta</h:eq>.</li> + </ol> + <p> + Comme pour l'algorithme <emph>LapS3L</emph>, nous étudions + différentes fonction de noyau : + </p> + <ul> + <li>le produit scalaire ;</li> + <li>la similarité cosinus ;</li> + <li>le noyau RBF.</li> + </ul> + <h3>Tuning local</h3> + <p> + En tant qu'extension de l'algorithme <emph>SSSL</emph>, nous + vérifions la pertinence des hyperparamètres introduits. Nous + commençons par tuner le noyau et le nombre de composantes pour + minimiser l'erreur de régression de + l'algorithme <emph>SSSL</emph>. Les valeurs obtenues sont + résumées dans la table <h:ref href="#tbl-local-hyper"/>. + </p> + <table latex-align="ccc"> + <caption id="tbl-local-hyper"> + Valeur des hyperparamètres minimisant l'erreur de régression + de l'algorithme <emph>SSSL</emph> sur les jeux de données + étudiés + </caption> + <thead> + <tr> + <th><strong>Jeu de données</strong></th> + <th><strong>Noyau</strong></th> + <th><strong>Nombre de composantes</strong></th> + </tr> + </thead> + <tbody> + <tr> + <td><emph>atp1d</emph></td> + <td>RBF, <h:eq>\gamma = 3.140 \cdot 10^{-05}</h:eq></td> + <td>202</td> + </tr> + <tr> + <td><emph>atp7d</emph></td> + <td>produit scalaire</td> + <td>5</td> + </tr> + <tr> + <td><emph>edm</emph></td> + <td>RBF, <h:eq>\gamma = 1.703 \cdot 10^{+01}</h:eq></td> + <td>107</td> + </tr> + <tr> + <td><emph>enb</emph></td> + <td>similarité cosinus</td> + <td>10</td> + </tr> + <tr> + <td><emph>jura</emph></td> + <td>RBF, <h:eq>\gamma = 4.272 \cdot 10^{-03}</h:eq></td> + <td>87</td> + </tr> + <tr> + <td><emph>oes10</emph></td> + <td>produit scalaire</td> + <td>31</td> + </tr> + <tr> + <td><emph>oes97</emph></td> + <td>RBF, <h:eq>\gamma = 3.785 \cdot 10^{-05}</h:eq></td> + <td>55</td> + </tr> + <tr> + <td><emph>osales</emph></td> + <td>RBF, <h:eq>\gamma = 1.254 \cdot 10^{-02}</h:eq></td> + <td>475</td> + </tr> + <tr> + <td><emph>scpf</emph></td> + <td>similarité cosinus</td> + <td>2</td> + </tr> + <tr> + <td><emph>sf1</emph></td> + <td>produit scalaire</td> + <td>5</td> + </tr> + <tr> + <td><emph>sf2</emph></td> + <td>similarité cosinus</td> + <td>3</td> + </tr> + <tr> + <td><emph>wq</emph></td> + <td>RBF, <h:eq>\gamma = 1.545 \cdot 10^{+01}</h:eq></td> + <td>774</td> + </tr> + </tbody> + </table> + <p> + En réutilisant ces valeurs, nous cherchons celles pour les deux + autres hyperparamètres. Nous comparons avec la performance de + <emph>SSSL</emph>, en calculant l'aRMSE relative comme le + rapport entre la performance de <emph>LSMR</emph> et la performance de + <emph>SSSL</emph>. Nous obtenons plusieurs cas de figure + différents, en fonction des jeux de données. Les principaux + types sont reportés dans la suite. + </p> + <h4>Tuning local : <emph>scpf</emph></h4> + <p> + Le jeu de données <emph>scpf</emph> regroupe des notices émises + par des habitants de certaines villes aux États-Unis à + destination de la municipalité. Ces notices sont décrites par + différentes variables, telles que la nature et la localisation + du problème signalé. Le but est de comprendre l'importance du + problème, en prédisant le nombre de vues, de clics et de + commentaires. + </p> + <p> + Le tuning local donne la figure + <h:ref href="#fig-local-scpf"/>. Le régulariseur multi-labels + n'est pas très pertinent dans ce cas ; il faut utiliser une + valeur très faible pour obtenir une amélioration de l'algorithme + <emph>SSSL</emph>. La zone où le tuning donne de bonnes + performances est très restreinte. + </p> + <figure> + <img src="images/lsmr_local_scpf.svg" /> + <figcaption id="fig-local-scpf"> + aRMSE relative pour le tuning local de <emph>LSMR</emph> sur + le jeu de données <emph>scpf</emph>. + </figcaption> + </figure> + <h4>Tuning local : <emph>osales</emph></h4> + <p> + Le jeu de données <emph>osales</emph> contient des produits + ayant eu droit à une campagne publicitaire. L'objectif est de + prédire le volume de vente de ces produits sur les 12 prochains + mois, un label par mois. + </p> + <p> + Le tuning local donne la figure + <h:ref href="#fig-local-osales"/>. La zone de tuning des + hyperparamètres <h:eq>\alpha</h:eq> et <h:eq>\beta</h:eq> donne + une place plus large pour lequel <emph>LSMR</emph> améliore les + résultats de <emph>SSSL</emph>, mais le meilleur point de tuning + se situe pour un regulariseur semi-supervisé faible, avec une + valeur non nulle du régulariseur multi-labels. + </p> + <figure> + <img src="images/lsmr_local_osales.svg" /> + <figcaption id="fig-local-osales"> + aRMSE relative pour le tuning local de <emph>LSMR</emph> sur + le jeu de données <emph>osales</emph>. + </figcaption> + </figure> + <h4>Tuning local : <emph>sf2</emph></h4> + <p> + Le jeu de données <emph>sf2</emph> considère comme individu une + période de 24h, et compte le nombre d'éruptions solaires de + différentes catégories dans cette période. La deuxième version + utilise des mesures prises en 1978. + </p> + <p> + Le tuning local donne la figure + <h:ref href="#fig-local-sf2"/>. La zone de tuning est là aussi + plus étendue, mais le résultat est meilleur pour une grande + valeur de chacun des deux hyperparamètres. + </p> + <figure> + <img src="images/lsmr_local_sf2.svg" /> + <figcaption id="fig-local-sf2"> + aRMSE relative pour le tuning local de <emph>LSMR</emph> sur + le jeu de données <emph>sf2</emph>. + </figcaption> + </figure> + <h4>Tuning local : <emph>oes97</emph></h4> + <p> + Enfin, <emph>oes97</emph> étudie différentes villes des + États-Unis (en 1997) et étudie la répartition des emplois dans + ces zones. Le but est de faire la prédiction de certaines + catégories d'emploi en fonction des autres pour une ville + donnée. + </p> + <p> + Le tuning local donne la figure + <h:ref href="#fig-local-oes97"/>. La zone de tuning est trop + étendue ; une valeur trop élevée du régulariseur multi-labels + fait chuter la performance de l'algorithme. + </p> + <figure> + <img src="images/lsmr_local_oes97.svg" /> + <figcaption id="fig-local-oes97"> + aRMSE relative pour le tuning local de <emph>LSMR</emph> sur + le jeu de données <emph>oes97</emph>. + </figcaption> + </figure> + <h4>Résultats du tuning local</h4> + <p> + En agrégeant les performances relatives sur tous les points de + tuning, on obtient la table + <h:ref href="#tbl-local-results"/>. Celle-ci montre que beaucoup + de points du tuning local donnent un meilleur résultat que + <emph>SSSL</emph>. L'agrégation des scores relatifs se fait avec + la moyenne, le premier et troisième quartile, le minimum et le + maximum. Sur tous les jeux de données, il existe un point où + <emph>LSMR</emph> est bien meilleur que <emph>SSSL</emph> + (valeur inférieure à 1), et un point où <emph>LSMR</emph> est + pire. En regardant les quartiles, il existe de larges zones dans + lesquelles <emph>LSMR</emph> tuné est meilleur + que <emph>SSSL</emph>. + </p> + <table latex-align="lccccc"> + <caption id="tbl-local-results"> + Tuning local : aRMSE moyenne relative de <strong>LSMR</strong> + par rapport à <emph>SSSL</emph> + </caption> + <thead> + <tr> + <th><strong>Jeu de données</strong></th> + <th><strong>Moyenne</strong></th> + <th><strong>Q1</strong></th> + <th><strong>Q3</strong></th> + <th><strong>Meilleur point</strong></th> + <th><strong>Pire point</strong></th> + </tr> + </thead> + <tbody> + <tr> + <td><emph>sf2</emph></td> + <td><strong>0.983</strong></td> + <td><strong>0.898</strong></td> + <td>1.086</td> + <td><strong>0.553</strong></td> + <td>1.245</td> + </tr> + <tr> + <td><emph>scpf</emph></td> + <td>1.191</td> + <td><strong>0.862</strong></td> + <td>1.554</td> + <td><strong>0.564</strong></td> + <td>1.684</td> + </tr> + <tr> + <td><emph>osales</emph></td> + <td><strong>0.989</strong></td> + <td><strong>0.938</strong></td> + <td>1.046</td> + <td><strong>0.635</strong></td> + <td>1.191</td> + </tr> + <tr> + <td><emph>oes97</emph></td> + <td>1.078</td> + <td><strong>0.872</strong></td> + <td>1.170</td> + <td><strong>0.662</strong></td> + <td>2.344</td> + </tr> + <tr> + <td><emph>sf1</emph></td> + <td><strong>0.994</strong></td> + <td><strong>0.922</strong></td> + <td>1.062</td> + <td><strong>0.682</strong></td> + <td>1.206</td> + </tr> + <tr> + <td><emph>oes10</emph></td> + <td>1.015</td> + <td><strong>0.908</strong></td> + <td>1.110</td> + <td><strong>0.715</strong></td> + <td>1.448</td> + </tr> + <tr> + <td><emph>jura</emph></td> + <td>1.014</td> + <td><strong>0.954</strong></td> + <td>1.065</td> + <td><strong>0.799</strong></td> + <td>1.485</td> + </tr> + <tr> + <td><emph>atp1d</emph></td> + <td>1.048</td> + <td><strong>0.958</strong></td> + <td>1.070</td> + <td><strong>0.812</strong></td> + <td>1.922</td> + </tr> + <tr> + <td><emph>edm</emph></td> + <td><strong>0.998</strong></td> + <td><strong>0.964</strong></td> + <td>1.037</td> + <td><strong>0.821</strong></td> + <td>1.190</td> + </tr> + <tr> + <td><emph>atp7d</emph></td> + <td>1.006</td> + <td><strong>0.961</strong></td> + <td>1.053</td> + <td><strong>0.833</strong></td> + <td>1.242</td> + </tr> + <tr> + <td><emph>enb</emph></td> + <td><strong>0.998</strong></td> + <td><strong>0.964</strong></td> + <td>1.027</td> + <td><strong>0.864</strong></td> + <td>1.124</td> + </tr> + <tr> + <td><emph>wq</emph></td> + <td><strong>0.999</strong></td> + <td><strong>0.992</strong></td> + <td>1.007</td> + <td><strong>0.960</strong></td> + <td>1.032</td> + </tr> + </tbody> + </table> + <h3>Tuning global</h3> + <p> + Nous mettons maintenant en place une approche de tuning global + de façon à comparer notre approche proposée à d'autres approches + de régularisation multi-labels pour la régression. Les méthodes + évoquées résolvent un problème de régression multi-labels + linéaire, en optimisant une fonction objectif convexe, au moyen + de l'algorithme de descente de gradient accélérée. + </p> + <h4>Ligne de base : sans régularisation</h4> + <p> + Notre ligne de base n'effectue pas de régularisation, elle est + notée <emph>LSQ</emph> (pour <emph>least squares</emph>). + </p> + <h4>Régularisation Lasso</h4> + <p> + La régularisation <h:eq>l_1</h:eq> permet d'obtenir des parties + du modèle ayant une valeur nulle + <h:cite href="tibshirani1996regression"/>. Nous le + notons <emph>MTL</emph> (<emph>multi-task learning</emph>). La + régularisation est donnée par : + </p> + <h:equation> + \left\|W\right\|_1 = \sum_{j = 1} ^ d \sum_{k = 1}^m \left|W_{j, k}\right| + </h:equation> + <h4>Régularisation Laplacienne</h4> + <p> + C'est la régularisation employée dans + l'algorithme <emph>LSMR</emph>. On la désigne + par <emph>SGR</emph>, pour <emph>sparse graph + regularization</emph> <h:cite href="malsar"/>. Le graphe est + construit avec des poids utilisant la similarité cosinus entre + les labels, d'après les valeurs qu'ont les + individus. Avec <h:eq>M</h:eq> la matrice + d'adjacence, <h:eq>D</h:eq> la matrice de degré + et <h:eq>L</h:eq> la matrice Laplacienne du graphe, la + régularisation est : + </p> + <h:equation> + \mathrm{tr} \left(WLW'\right) = \sum_{k_1, k_2 = 1}^m M_{k_1, k_2} \left\|W_{., k_1} - W_{., k_2}\right\|_2^2 + </h:equation> + <h4>Régularisation Lasso par groupe</h4> + <p> + L'algorithme <emph>JFS</emph> (<emph>joint feature + selection</emph>) tel que défini par + <h:cite href="argyriou_multitask_nodate"/> utilise le Lasso + par groupe. La régularisation employée est : + </p> + <h:equation> + \left\|W\right\|_{2, 1} = \sum_{j = 1} ^ d \left\|W_{j, .}\right\|_2^2 + </h:equation> + <h4>Régularisation du rang</h4> + <p> + La régularisation du rang peut s'effectuer en régularisant la + norme trace <h:cite href="rank"/>, <emph>TNR</emph> (<emph>trace + norm regularization</emph>). La régularisation employée est : + </p> + <h:equation> + \left\|W\right\|_{*} = \sum_{\sigma \mathrm{~valeur~propre~de~} W} \sigma + </h:equation> + <h4>Dirty model</h4> + <p> + La régularisation du <emph>Dirty Model</emph> + <h:cite href="jalali_dirty_nodate"/> (<emph>DM</emph>) est en + deux termes, pour un modèle qui se décompose en <h:eq>W = P + + Q</h:eq> : + </p> + <h:equation> + \alpha \left\|P\right\|_{1, 1} + \beta \left\|Q\right\|_{\infty, 1} + = \alpha \sum_{j = 1} ^d \sum_{k = 1}^m \left|P_{j, k}\right| + + \beta \sum_{j = 1} ^ d \left\|Q_{j, .}\right\|_{\infty} + </h:equation> + <h4>Clustered multi-task learning</h4> + <p> + <emph>CMTL</emph> est la version convexe de cet algorithme + <h:cite href="cmtl"/>. L'optimisation se fait sur deux + variables, le modèle <h:eq>W</h:eq> et une matrice symétrique + semi-définie positive <h:eq>M</h:eq> telle que <h:eq>I - + M</h:eq> est aussi semi-définie positive. + </p> + <h:equation> + \alpha \mathrm{tr} \left(W \left(M + \beta I\right)^{-1}W'\right) + </h:equation> + <h4>Résultats</h4> + <p> + La table <h:ref href="#tuning-global"/> montre les résultats des + différentes approches. Nous remarquons que : + </p> + <ul> + <li> + notre approche, pour un tuning global, est meilleure + que <emph>SSSL</emph>, cependant le tuning local est + insuffisant ; + </li> + <li> + notre approche est souvent meilleure que la régularisation multi-labels <emph>SGR</emph> ; + </li> + <li> + le tuning global pour notre approche donne très souvent de + meilleurs résultats que le tuning local ; + </li> + <li> + contrairement à <emph>SSSL</emph>, notre approche donne des + résultats comparables à l'état de l'art sur les jeux de + données considérés, pour des approches de régularisation. + </li> + </ul> + <table latex-align="|l|cc|cccccccc|" sideways="sideways"> + <caption id="tuning-global"> + Résultats du tuning global, métrique aRMSE + </caption> + <thead> + <tr> + <th><strong>Jeu de données</strong></th> + <th><strong>LSMR</strong></th> + <th><strong>LSMR local</strong></th> + <th><emph>SSSL</emph></th> + <th><emph>CMTL</emph></th> + <th><emph>DM</emph></th> + <th><emph>JFS</emph></th> + <th><emph>LSQ</emph></th> + <th><emph>MTL</emph></th> + <th><emph>SGR</emph></th> + <th><emph>TNR</emph></th> + </tr> + </thead> + <tbody> + <tr> + <td><emph>atp1d</emph></td> + <td><strong>0.472</strong></td> + <td>1.006</td> + <td>0.481</td> + <td>0.533</td> + <td>0.522</td> + <td>0.543</td> + <td>0.549</td> + <td>0.534</td> + <td>0.548</td> + <td>0.548</td> + </tr> + <tr> + <td><emph>atp7d</emph></td> + <td>0.888</td> + <td><strong>0.713</strong></td> + <td>0.779</td> + <td>0.727</td> + <td>0.782</td> + <td>0.764</td> + <td>0.787</td> + <td>0.787</td> + <td>0.787</td> + <td>0.787</td> + </tr> + <tr> + <td><emph>edm</emph></td> + <td><strong>0.841</strong></td> + <td>1.005</td> + <td>0.895</td> + <td>0.849</td> + <td>0.857</td> + <td>0.856</td> + <td>1.198</td> + <td>0.855</td> + <td>1.207</td> + <td>0.852</td> + </tr> + <tr> + <td><emph>enb</emph></td> + <td><strong>0.320</strong></td> + <td>0.541</td> + <td>0.339</td> + <td>0.332</td> + <td>0.333</td> + <td>0.332</td> + <td>0.332</td> + <td>0.332</td> + <td>0.332</td> + <td>0.332</td> + </tr> + <tr> + <td><emph>jura</emph></td> + <td>0.661</td> + <td>0.847</td> + <td>0.727</td> + <td>0.597</td> + <td>0.593</td> + <td><strong>0.591</strong></td> + <td>0.609</td> + <td>0.593</td> + <td>0.611</td> + <td>0.598</td> + </tr> + <tr> + <td><emph>oes10</emph></td> + <td><strong>0.390</strong></td> + <td>0.488</td> + <td>0.395</td> + <td>0.398</td> + <td>0.402</td> + <td>0.402</td> + <td>0.402</td> + <td>0.402</td> + <td>0.402</td> + <td>0.402</td> + </tr> + <tr> + <td><emph>oes97</emph></td> + <td><strong>0.445</strong></td> + <td>0.918</td> + <td>0.494</td> + <td>0.515</td> + <td>0.510</td> + <td>0.534</td> + <td>0.534</td> + <td>0.534</td> + <td>0.534</td> + <td>0.534</td> + </tr> + <tr> + <td><emph>osales</emph></td> + <td>1.012</td> + <td>0.957</td> + <td>0.938</td> + <td>0.882</td> + <td><strong>0.839</strong></td> + <td>0.861</td> + <td>0.921</td> + <td>0.873</td> + <td>0.873</td> + <td>0.906</td> + </tr> + <tr> + <td><emph>sarcossub</emph></td> + <td>0.363</td> + <td>0.816</td> + <td>0.428</td> + <td>0.357</td> + <td>0.357</td> + <td><strong>0.354</strong></td> + <td>0.357</td> + <td>0.354</td> + <td>0.357</td> + <td>0.357</td> + </tr> + <tr> + <td><emph>scpf</emph></td> + <td>1.111</td> + <td>0.926</td> + <td>1.253</td> + <td><strong>0.621</strong></td> + <td>0.636</td> + <td>0.635</td> + <td>0.635</td> + <td>0.635</td> + <td>0.635</td> + <td>0.635</td> + </tr> + <tr> + <td><emph>sf1</emph></td> + <td>1.070</td> + <td><strong>0.998</strong></td> + <td>1.092</td> + <td>0.999</td> + <td>0.999</td> + <td>0.999</td> + <td>1.292</td> + <td>0.999</td> + <td>1.285</td> + <td>0.999</td> + </tr> + <tr> + <td><emph>sf2</emph></td> + <td><strong>0.973</strong></td> + <td>1.041</td> + <td>1.114</td> + <td>1.022</td> + <td>1.161</td> + <td>1.024</td> + <td>1.262</td> + <td>1.024</td> + <td>1.249</td> + <td>1.024</td> + </tr> + <tr> + <td><emph>wq</emph></td> + <td>0.999</td> + <td>0.999</td> + <td>1.003</td> + <td><strong>0.946</strong></td> + <td>1.006</td> + <td>0.982</td> + <td>1.079</td> + <td>0.947</td> + <td>1.079</td> + <td>1.023</td> + </tr> + </tbody> + </table> + <h3>Validation statistique</h3> + <p> + Afin de savoir comment se positionnent les algorithmes les uns + par rapport aux autres, nous effectuons un test statistique en + suivant la méthodologie indiquée dans + <h:cite href="demsar_statistical_2006"/>. + </p> + <h4><emph>t-test</emph> par paires</h4> + <p> + En considérant une paire d'algorithmes, il est possible de + calculer la différence entre les performances de ces deux + algorithmes sur chaque jeu de données. Lorsque l'on prend la + moyenne de cette différence, à supposer qu'elle s'applique sur + un grand nombre de jeux de données, on peut effectuer un test + pour savoir si cette moyenne est positive, ou pour savoir si + elle est négative. Cela permettrait de savoir si l'un des + algorithmes est relativement meilleur que l'autre. + </p> + <p> + Comme nous n'avons que 13 jeux de données, il n'est pas possible + de considérer les performances de chaque algorithme comme un + échantillon gausssien, ce qui pose une limite assez claire à + cette approche. + </p> + <p> + De plus, les jeux de données contenant très peu d'individus ont une + performance très variable. + </p> + <h4>Test de Wilcoxon</h4> + <p> + Ce test permet aussi de départager deux algorithmes, mais il ne + se fonde plus sur les valeurs de la métrique envisagée mais sur + les rangs des algorithmes. Plus précisément, on calcule les + différences entre les deux algorithmes sur chaque jeu de données + en valeur absolue, puis on trie ces différences absolues. Pour + chaque algorithme, on sélectionne les différences qui sont en + faveur de cet algorithme, et on somme leurs rangs. En prenant + une valeur de <h:eq>\alpha = 0.1</h:eq>, on obtient la figure + <h:ref href="#fig-test-wilcoxon"/>. Sur cette figure, une + cellule bleue indique que l'algorithme en ligne bat l'algorithme + en colonne. Une cellule rouge indique que l'algorithme en + colonne bat l'algorithme en ligne. Notre généralisation est + meilleure que l'algorithme <emph>SSSL</emph>. + </p> + <figure> + <img src="images/wilcoxon.svg" /> + <figcaption id="fig-test-wilcoxon"> + Résultat du test de comparaison par paires d'algorithmes de + Wilcoxon + </figcaption> + </figure> + <h4>Tests de Friedman et Nemenyi</h4> + <p> + Le test de Friedman permet de rejeter l'hypothèse suivante en se + fondant sur les rangs des approches : tous les régresseurs sont + équivalents, c'est-à-dire que le rang moyen de tous les + régresseurs est égal. Cette hypothèse est rejetée dans notre cas + pour un risque <h:eq>\alpha = 0.05</h:eq>. + </p> + <p> + Puisque le rang moyen n'est pas égal, le test de Nemenyi permet + d'établir la distance critique entre rangs moyens. Si des + algorithmes ont une différence entre leurs rangs moyens + supérieure à cette distance critique, ils ne sont pas + équivalents. La figure <h:ref href="#fig-test-nemenyi"/> montre + les rangs des algorithmes, ainsi que la distance critique. On + constate que notre approche, même si elle n'obtient pas le + meilleur rang moyen, est dans le groupe du meilleur algorithme, + contrairement aux deux approches sur lesquelles elle est fondée. + </p> + <figure> + <img src="images/nemenyi.svg" /> + <figcaption id="fig-test-nemenyi"> + Résultat du test de comparaison par paires d'algorithmes de + Nemenyi + </figcaption> + </figure> + <h2>Conclusion</h2> + <p> + Nous avons proposé une extension de + l'algorithme <emph>SSSL</emph> adapté à l'apprentissage + multi-labels, en réutilisant la régularisation Laplacienne que + nous avions développée dans l'algorithme + <emph>LapS3L</emph>. Expérimentalement, cette approche donne une + erreur de régression multi-labels plus faible + que <emph>SSSL</emph>, même en réutilisant une partie du tuning + des hyperparamètres. En optimisant les hyperparamètres de façon + globale, l'approche demeure compétitive avec des méthodes + représentatives de l'état de l'art. + </p> + <h1 short="RSMS"> + Sélection de variables semi-supervisée en multi-régressions + </h1> + <h:résumé-chapitre> + <p> + Les deux travaux présentés dans les chapitres précédents, + <strong>LapS3L</strong> et sa version + multi-labels, <strong>LSMR</strong>, utilisent + une <emph>extraction de variables</emph> non supervisée pour + réduire la dimension du problème. + </p> + <p> + Dans certains cas d'application, cependant, la <emph>sélection + de variables</emph> est une tâche plus abordée puisqu'elle + rend le modèle <emph>interprétable</emph>. Dans ce chapitre, + nous proposons de résoudre cette tâche dans un cadre à la fois + multi-labels et semi-supervisé pour les problèmes de + régression, et montrons son efficacité sur des jeux de données + multi-labels publics issus de la littérature. + </p> + <p> + L'idée de cette méthode consiste à guider la sélection de + variables par la <emph>sélection de labels</emph> : en effet, + si les performances d'apprentissage sont dégradées pour + certains labels, il n'est pas nécessaire de les conserver pour + la sélection de variables. + </p> + </h:résumé-chapitre> + <h2>Introduction</h2> + <p> + Dans le cas d'apprentissage multi-labels dont l'espace de + description des individus est de grande dimension, ce qui arrive + pour des données textuelles ou d'images par exemple, la présence + de trop de variables par rapport au nombre d'individus peut + mener à un sur-apprentissage. Pour empêcher cela, la sélection + de variables multi-labels a pour objectif de trouver un + sous-ensemble de variables pertinentes pour tous les labels, + permettant d'obtenir une meilleure erreur de régression, de + réduire la dimension du problème et de produire un modèle plus + simple et interprétable. + </p> + <p> + Dans ce chapitre, nous proposons un algorithme de sélection de + variables semi-supervisé et multi-labels, adapté aux problèmes + de régression. Tout d'abord, nous rappelons le contexte ainsi + que les travaux existants sur lesquels nous nous + appuyons. Ensuite, nous développons l'algorithme, à partir de + l'explicitation de notre intuition. Enfin, pour valider notre + approche, nous proposons une étude expérimentale comparative sur + des jeux de données de régression multi-labels. + </p> + <h2>Travaux liés</h2> + <p> + L'approche que nous proposons s'inspire principalement de l'algorithme + <emph>MIFS</emph> (<emph>Multi-label Informed Feature + Selection</emph>) dans les travaux de <h:cite href="mifs"/>, de + façon à fonctionner dans le cadre semi-supervisé, et en + régression. Nous proposons également des éléments de + l'apprentissage robuste et de la sélection de labels. + </p> + <p> + Dans le cadre de la sélection de variables, + l'algorithme <emph>MIFS</emph> propose un <emph>embedding</emph> + des labels. Ainsi, les variables ne sont pas sélectionnées pour + améliorer la prédiction des vrais labels, mais des labels + extraits. L'avantage de cette approche est que des valeurs + bruitées dans l'ensemble d'apprentissage perturberont peu la + sélection de variables. En revanche, la méthode ne peut pas + servir directement en prédiction pour faire simultanément de la + sélection de variables et de la régresssion multi-labels. + </p> + <p> + Pour rappel, l'algorithme <emph>MIFS</emph> vise à minimiser la + fonction objectif suivante : + </p> + <h:mini> + <h:variables> + W \in \mathbb{R}^{d, o}, + V \in \mathbb{R}^{n, o}, + B \in \mathbb{R}^{o, m} + </h:variables> + <h:objective> + \left\|XW - V\right\|_F^2 + + \alpha \left\|Y - VB\right\|_F^2 + + \beta \mathrm{tr} \left(V'LV\right) + + \gamma \left\|W\right\|_{2, 1} + </h:objective> + </h:mini> + <p> + Cette fonction objectif se décompose en 4 termes : + </p> + <ol> + <li> + L'erreur de régression pour prédire les labels extraits ; + </li> + <li> + La précision de l'extraction des labels ; + </li> + <li> + La cohérence des labels extraits : si deux individus sont + proches dans l'espace des variables, alors les valeurs de + leurs labels extraits doivent être également proches ; + </li> + <li> + La sélection de variables, sur le modèle prédisant les labels + extraits. + </li> + </ol> + <p> + Cependant, la pénalisation de l'extraction de labels prévue par + <emph>MIFS</emph> n'est pas suffisante dans les cas où certains + des labels dont on souhaite effectuer la prédiction ne peuvent + tout simplement pas être traités. Si de tels labels sont + présents dans le jeu de données, la prédiction pour ces labels + sera mauvaise quelles que soient les variables sélectionnées : + il ne faut pas sélectionner de variables pertinentes pour ces + labels. De ce point de vue, la sélection de labels au service de + la sélection de variables joue un rôle différent de l'extraction + de labels telle que mise en œuvre dans + l'algorithme <emph>MIFS</emph>. + </p> + <p> + La sélection de labels peut donc être utilisée pour + l'apprentissage multi-labels <h:cite href="robust"/>. Dans ce + cas, le modèle multi-labels est décomposé en un terme utilisant + une structure commune pour la plupart des labels, et un terme + indiquant les labels non traités. + </p> + <h:mini> + <h:variables>A, B</h:variables> + <h:objective> + \left\|X (A + B) - Y\right\|_F^2 + + \alpha \mathcal{R} (A) + + \beta \left\|B\right\|_{1, 2} + </h:objective> + </h:mini> + <p> + La notation <h:eq>\left\|B\right\|_{1, 2}</h:eq> désigne la + norme <h:eq>l_{1, 2}</h:eq> de <h:eq>B</h:eq>, c'est-à-dire la + norme <h:eq>l_{2, 1}</h:eq> de la transposée de <h:eq>B</h:eq> : + </p> + <h:equation> + \left\|B\right\|_{1, 2} + = \sum_{l = 1} ^ m \left\|B_{., l}\right\|_2 + </h:equation> + <p> + <h:eq>\mathcal{R}</h:eq> désigne un terme de régularisation + multi-labels quelconque. Dans le cas de <h:cite href="robust"/>, + il s'agit de la norme trace. La régularisation + <h:eq>\left\|B\right\|_{1, 2}</h:eq> ressemble au terme de + sparsité du <emph>dirty model</emph>, mais l'hypothèse est plus + forte, puisque ce terme ne correspond qu'à certains labels. + </p> + <h2>Approche proposée : <strong>RSMS</strong></h2> + <p> + Dans cette section nous décrivons notre approche que nous + dénommons par la suite <strong>RSMS</strong> (<emph>Robust + Semi-supervised Multi-label feature Selection</emph>). + </p> + <p> + On dispose d'un ensemble d'apprentissage supervisé, + + <h:eq> + \left( + x_i \in \mathcal{X}, + y_i \in \mathbb{R}^m + \right)_{i = 1} ^ {n_l} + </h:eq>, + + auquel est adjoint un ensemble non supervisé, + + <h:eq> + \left( + x_i \in \mathcal{X} + \right)_{i = n_l + 1}^{N} + </h:eq>. + </p> + <p> + Tout d'abord, l'algorithme cherche à effectuer une extraction de + labels. Pour cela, on écrit la matrice de labels <h:eq>Y</h:eq> + comme suit : + </p> + <h:equation-x> + Y = V B + </h:equation-x> + <p> + Ceci introduit la matrice de pseudo-labels + + <h:eq>V \in \mathbb{R}^{N, o}</h:eq>, + + et la matrice + + <h:eq>B \in \mathbb{R}^{o, m}</h:eq>. + + Concrètement, chaque individu labellisé de l'ensemble + d'apprentissage correspond à une ligne de <h:eq>V</h:eq>, et + chaque pseudo-label correspond à une colonne + de <h:eq>V</h:eq>. Dans le cadre semi-supervisé, on définit une + matrice diagonale + + <h:eq>J \in \mathbb{R}^{N, N}</h:eq>, + + dont la diagonale est l'indicatrice des individus + labellisés. Pour chaque individu + + <h:eq>i \in \{1, ..., N\}</h:eq>, + + <h:eq>J_{i i} = 1</h:eq> si et seulement si <h:eq>i</h:eq> est + labellisé. Cette matrice nous permet donc d'affiner la + décomposition, qui ne doit porter que sur la partie labellisée : + </p> + <h:mini> + <h:variables> + V \in \mathbb{R}^{N, o}, + B \in \mathbb{R}^{o, m} + </h:variables> + <h:objective> + \left\|JVB - JY\right\|_F^2 + </h:objective> + </h:mini> + <p> + L'obtention d'un modèle d'apprentissage semi-supervisé peut + ainsi s'effectuer uniquement à partir des labels extraits. On + introduit un modèle + + <h:eq>W \in \mathbb{R}^{d, o}</h:eq>, + + et un régulariseur + + <h:eq>\alpha > 0</h:eq>. + + Plus <h:eq>\alpha</h:eq> est grand, plus les labels extraits + représenteront fidèlement les vrais labels <h:eq>Y</h:eq>. + </p> + <h:mini> + <h:variables> + W \in \mathbb{R}^{d, o}, + V \in \mathbb{R}^{N, o}, + B \in \mathbb{R}^{o, m} + </h:variables> + <h:objective> + \left\|XW - V\right\|_F^2 + + \alpha \left\|J V B - J Y \right\|_F^2 + </h:objective> + </h:mini> + <p> + L'optimisation par rapport à <h:eq>V</h:eq> permet d'assigner + des pseudo-labels même aux individus non labellisés. Ce n'est + cependant pas suffisant pour tenir compte des hypothèses de + l'apprentissage semi-supervisé, puisque ces valeurs ne sont pas + contraintes. La traduction des hypothèses semi-supervisées, dans + le cadre de l'algorithme <emph>MIFS</emph>, se traduit de la + façon suivante : + </p> + <blockquote> + Si deux individus sont proches, alors les valeurs de leurs + pseudo-labels doivent être proches. + </blockquote> + <p> + En suivant cette hypothèse, on peut être amené à introduire une + matrice Laplacienne + + <h:eq>L \in \mathbb{R}^{N, N}</h:eq> + + et un nouveau régulariseur + + <h:eq>\beta > 0</h:eq>, + + de sorte à minimiser le problème suivant : + </p> + <h:mini> + <h:variables> + W \in \mathbb{R}^{d, o}, + V \in \mathbb{R}^{N, o}, + B \in \mathbb{R}^{o, m} + </h:variables> + <h:objective> + \left\|XW - V\right\|_F^2 + + \alpha \left\|J V B - J Y \right\|_F^2 + + \beta \mathrm{tr} \left(V'LV\right) + </h:objective> + </h:mini> + <p> + Il reste donc deux problèmes à traiter : la sélection de + variables, et la sélection de labels au service de la sélection + de variables. Pour la sélection de variables, l'utilisation de + la norme <h:eq>l_{2, 1}</h:eq> est très répandue + <h:cite href="rfs"/>. Pour rappel, il s'agit de régulariser le + terme s'appliquant sur les lignes de <h:eq>W</h:eq> : + </p> + <h:equation-x> + \sum_{j = 1} ^ d \sqrt{\sum_{k = 1} ^ o W_{jk} ^ 2} + = \left\|W\right\|_{2, 1} + </h:equation-x> + <p> + Ce terme permet de rendre les lignes de <h:eq>W</h:eq> éparses, + c'est-à-dire que des lignes de <h:eq>W</h:eq> tendent à être + entièrement nulles. Les lignes comportant des valeurs non nulles + indiquent des variables qui sont importantes pour + l'apprentissage de tous les pseudo-labels. Le problème devient + donc : + </p> + <h:mini> + <h:variables> + W \in \mathbb{R}^{d, o}, + V \in \mathbb{R}^{N, o}, + B \in \mathbb{R}^{o, m} + </h:variables> + <h:objective> + \left\|XW - V\right\|_F^2 + + \alpha \left\|J V B - J Y \right\|_F^2 + </h:objective> + <h:break-objective> + + \beta \mathrm{tr} \left(V'LV\right) + + \gamma \left\|W\right\|_{2, 1} + </h:break-objective> + </h:mini> + <p> + Pour effectuer la sélection de labels, notre hypothèse se + traduit donc par le fait que certaines des colonnes de la + matrice <h:eq>B</h:eq>, qui correspondent donc aux vrais labels, + seront entièrement nulles. En introduisant un terme de + régularisation supplémentaire, on obtient : + </p> + <h:mini> + <h:variables> + W \in \mathbb{R}^{d, o}, + V \in \mathbb{R}^{N, o}, + B \in \mathbb{R}^{o, m} + </h:variables> + <h:objective> + \left\|XW - V\right\|_F^2 + + \alpha \left\|J V B - J Y \right\|_F^2 + </h:objective> + <h:break-objective> + + \beta \mathrm{tr} \left(V'LV\right) + + \gamma \left\|W\right\|_{2, 1} + + \delta \left\|B\right\|_{1, 2} + </h:break-objective> + </h:mini> + <p> + L'hypothèse semi-supervisée change également. La régularisation + + <h:eq>\mathrm{tr} (V L V')</h:eq> + + n'est pas pertinente, parce qu'elle s'applique de façon + indiscriminée sur tous les pseudo-labels. Ainsi, si un + pseudo-label représente l'un des labels ignorés, il ne faut pas + tenir compte de ses valeurs pour la régularisation. Ceci nous + mène à modifier l'hypothèse semi-supervisée pour la sélection de + variables aidée par la sélection de labels : + </p> + <blockquote> + Si deux individus sont proches, alors pour chaque label + sélectionné, la reconstruction des valeurs de ce label doivent + être proches. + </blockquote> + <p> + Nous considérons pour la reconstruction des valeurs des labels + le produit <h:eq>V B</h:eq>. Le problème final devient donc + <h:ref href="#rsms-final"/> : + </p> + <h:mini id="rsms-final"> + <h:variables> + W \in \mathbb{R}^{d, o}, + V \in \mathbb{R}^{N, o}, + B \in \mathbb{R}^{o, m} + </h:variables> + <h:objective> + \left\|XW - V\right\|_F^2 + + \alpha \left\|J V B - J Y \right\|_F^2 + </h:objective> + <h:break-objective> + + \beta \mathrm{tr} \left(B'V'LVB\right) + + \gamma \left\|W\right\|_{2, 1} + + \delta \left\|B\right\|_{1, 2} + </h:break-objective> + </h:mini> + <p> + Le terme de régularisation semi-supervisé + + <h:eq>\mathrm{tr} \left(B'V'LVB\right)</h:eq> + + peut se réécrire de la façon suivante : + </p> + <h:equation> + \sum_{k = 1} ^ m \sum_{i_1 = 1, i_2 = 1} ^ N M_{i_1, i_2} + \left( + \sum_{l = 1} ^ o \left(V_{i_1, l} - V_{i_2, l}\right) B_{l, k} + \right)^2 + </h:equation> + <p> + Par hypothèse, si un label <h:eq>k</h:eq> est ignoré, alors pour + tout + + <h:eq>l \in \{1, ..., o\}</h:eq>, + + <h:eq>B_{l,k} = 0</h:eq>. + + Par conséquent, la régularisation ne porte que sur les labels + non ignorés, notés + + <h:eq>\mathcal {S} \subset \{1, ..., m\}</h:eq> : + </p> + <h:equation> + \sum_{k \in \mathcal{S}} + \sum_{i_1 = 1, i_2 = 1} ^ N + M_{i_1, i_2} \left( + \sum_{l = 1} ^ o \left(V_{i_1, l} - V_{i_2, l}\right) B_{l, k} + \right)^2 + </h:equation> + <p> + Contrairement à l'apprentissage robuste <h:cite href="robust"/>, + où le modèle doit rendre compte à la fois des labels + sélectionnés et des labels non sélectionnés, nous ne nous + intéressons qu'aux variables pour les labels sélectionnés. Il + n'est donc pas nécessaire de décomposer le terme <h:eq>B</h:eq>. + </p> + <h2>Optimisation</h2> + <p> + La question de l'initialisation des variables pose problème, + puisque le résultat final en dépend. Il est possible d'utiliser + des variables indépendantes suivant une loi normale, mais cela + ne permet pas de rendre l'algorithme déterministe. + </p> + <p> + En ce qui concerne <h:eq>W</h:eq>, nous avons choisi d'utiliser + l'initialisation suivante : + </p> + <h:equation> + W^{(0)} \gets \left[X' J X + \epsilon I\right]^{-1} X' J V + </h:equation> + <p> + Il s'agit de la solution aux moindres carrés, régularisée par + <h:eq>\epsilon</h:eq>. La valeur a été fixée + à <h:eq>10^{-6}</h:eq>, qui est suffisamment faible pour ne pas + trop influencer l'apprentissage pour les jeux de données du type + de ceux étudiés dans l'étude expérimentale. Le + terme <h:eq>V_l</h:eq> désigne le sous-ensemble labellisé des + lignes de <h:eq>V</h:eq>. + </p> + <p> + Pour <h:eq>V</h:eq> et <h:eq>B</h:eq>, la question est plus + complexe. Pour conserver l'aspect déterministe de + l'initialisation, on ne peut pas recourir à un algorithme de + clustering de type <emph>k-means</emph>, et il n'est pas non + plus possible d'effectuer une décomposition <emph>SVD</emph> de + la matrice <h:eq>Y</h:eq>. L'initialisation retenue + pour <h:eq>B</h:eq> est une matrice diagonale rectangulaire (la + diagonale s'arrêtant prématurément, laissant des colonnes + nulles). L'initialisation pour <h:eq>V_l</h:eq> correspond donc + aux valeurs des <h:eq>o</h:eq> premiers labels. Le reste des + valeurs de <h:eq>V</h:eq> est obtenue en utilisant la valeur + initiale <h:eq>W^{(0)}</h:eq> de <h:eq>W</h:eq> sous la forme + <h:eq>V^{(0)} \gets X W</h:eq>. + </p> + <p> + L'initialisation de l'algorithme consiste donc à faire un + apprentissage des <h:eq>o</h:eq> premiers labels avec une + régularisation Ridge de paramètre <h:eq>10^{-6}</h:eq>. + </p> + <p> + Comme pour l'algorithme <emph>MIFS</emph>, notre approche + utilise 3 variables + d'optimisation : <h:eq>W</h:eq>, <h:eq>V</h:eq> + et <h:eq>B</h:eq>. En effectuant une optimisation alternée + vis-à-vis de chacune des variables, nous pouvons vérifier que la + valeur de la fonction objectif décroît à chaque étape, ce qui + montre la convergence de notre approche. + </p> + <h3>Optimisation vis-à-vis de <h:eq>W</h:eq>, <h:eq>V</h:eq> + et <h:eq>B</h:eq> étant fixés</h3> + <p> + Le problème <h:ref href="#rsms-final"/>, si l'on ne considère + que <h:eq>W</h:eq>, peut se réécrire en : + </p> + <h:mini> + <h:variables> + W \in \mathbb{R}^{d, o} + </h:variables> + <h:objective> + \left\|XW - V\right\|_F^2 + + \gamma \left\|W\right\|_{2, 1} + </h:objective> + </h:mini> + <p> + La difficulté de ce problème réside dans le fait que le deuxième + terme n'est pas lisse. Il existe plusieurs façons de traiter ce + cas, par exemple l'implémentation MALSAR <h:cite href="malsar"/> + propose une descente de gradient proximal. Dans notre cas, nous + utilisons une constante <h:eq>\epsilon > 0</h:eq>, et nous + adoptons la solution de l'algorithme <emph>RFS</emph> + <h:cite href="rfs"/>, en posant la matrice + diagonale <h:eq>D_W</h:eq> telle que : + </p> + <h:equation> + \forall j \in \{1, ..., d\}, {D_W}_{j, j} = + \begin{cases} + \frac 1 {2 \left\|W_{j,.}\right\|_2}, \quad \left\|W_{j,.}\right\|_2 \neq 0 \\ + \epsilon, \quad \left\|W_{j,.}\right\|_2 = 0 + \end{cases} + </h:equation> + <p> + Cette définition permet d'écrire : + </p> + <h:equation> + 2 \mathrm{tr} (W' D_W W) + = \sum_{j = 1, \left\|W_{j, .}\right\|_2 \neq 0}^d + \left\|W_{j, .}\right\|_2 + + \sum_{j = 1, \left\|W_{j, .}\right\|_2 = 0} + \epsilon \left\|W_{j,.}\right\|_2^2 + </h:equation> + <p> + Il s'agit donc de la norme <h:eq>l_{2,1}</h:eq>. En pratique, + pour vérifier la convergence de l'algorithme, si le terme + + <h:eq>\mathrm{tr} (W' D_W W)</h:eq> + + décroît, alors le terme <h:eq>\left\|W\right\|_{2, 1}</h:eq> + décroît aussi. + </p> + <p> + Le gradient vis-à-vis de <h:eq>W</h:eq> s'écrit donc : + </p> + <h:equation> + 2 \left (X' (XW - V) + \gamma D_W W \right) + </h:equation> + <p> + Si l'on pose : + </p> + <h:equation> + W^{*} \gets W - \frac 2 {C_W} (X' (XW - V) + \gamma D_W W) + </h:equation> + <p> + on applique une itération de l'algorithme de descente du + gradient, avec un pas d'apprentissage <h:eq>\frac 1 + {C_W}</h:eq>. On constate que la fonction gradient est + Lipschitzienne, c'est-à-dire que pour toute paire de modèles + <h:eq>W^{(1)}, W^{(2)}</h:eq>, + </p> + <h:equation> + \left\|\nabla_W (W^{(1)}) - \nabla_W (W^{(2)})\right\|_F^2 + \leq C_W \left\|W^{(1)} - W^{(2)}\right\|_F^2 + </h:equation> + <p> + avec + + <h:eq>C_W = \rho (X'X) + \gamma \max (D_W)</h:eq>, + + où <h:eq>\rho (X'X)</h:eq> est le rayon spectral de la matrice + <h:eq>X'X</h:eq>. + </p> + <p> + Par conséquent, l'itération de descente de gradient fait + décroître la fonction objectif. + </p> + <h3>Optimisation vis-à-vis de <h:eq>V</h:eq></h3> + <p> + En fixant <h:eq>W</h:eq> et <h:eq>B</h:eq>, le problème + d'optimisation s'écrit : + </p> + <h:mini> + <h:variables> + V \in \mathbb{R}^{N, o} + </h:variables> + <h:objective> + \left\|XW - V\right\|_F^2 + + \alpha \left\|JVB - JY\right\|_F^2 + + \beta \mathrm{tr}\left(B'V'LVB\right) + </h:objective> + </h:mini> + <p> + Le gradient par rapport à <h:eq>V</h:eq> s'écrit : + </p> + <h:equation> + 2 \left( V - X W + \alpha JVB' - \alpha JYB' + \beta L V B B' \right) + </h:equation> + <p> + La fonction objectif est convexe par rapport à <h:eq>V</h:eq>, + et la fonction de gradient est Lipschitzienne : pour toute paire + de modèles <h:eq>V^{(1)}, V^{(2)}</h:eq>, + </p> + <h:equation> + \left\|\nabla_V (V^{(1)}) - \nabla_V (V^{(2)})\right\|_F^2 + \leq C_V \left\|V^{(1)} - V^{(2)}\right\|_F^2 + </h:equation> + <p> + avec : + </p> + <h:equation> + C_V = 1 + \left(\alpha + \beta \rho (L)\right) \rho (BB') + </h:equation> + <h3>Optimisation vis-à-vis de <h:eq>B</h:eq></h3> + <p> + En fixant <h:eq>W</h:eq> et <h:eq>V</h:eq>, le problème + d'optimisation s'écrit : + </p> + <h:mini> + <h:variables> + B \in \mathbb{R}^{o, m} + </h:variables> + <h:objective> + \alpha \left\|JVB - JY\right\|_F^2 + + \beta \mathrm{tr} \left(B'V'LVB\right) + + \delta \left\|B\right\|_{1, 2} + </h:objective> + </h:mini> + <p> + Cette fonction n'est pas lisse, à cause de la + norme <h:eq>l_{1,2}</h:eq> appliquée à <h:eq>B</h:eq>. On + applique la même astuce que pour l'optimisation par rapport à + <h:eq>W</h:eq> : on pose la matrice diagonale <h:eq>D_B</h:eq> + dont la diagonale vaut : + </p> + <h:equation> + \forall l \in \{1, ..., m\}, \quad {D_B}_{l, l} \gets + \begin{cases} + \frac 1 {2 \left\|B_{., l}\right\|_2}, &\quad \left\|B_{., l}\right\|_2 \neq 0 \\ + \epsilon, &\quad \left\|B_{., l}\right\|_2 = 0 + \end{cases} + </h:equation> + <p> + Nous devons donc résoudre le problème suivant : + </p> + <h:mini> + <h:variables> + B \in \mathbb{R}^{o, m} + </h:variables> + <h:objective> + \alpha \left\|JVB - JY\right\|_F^2 + + \beta \mathrm{tr} \left(B'V'LVB\right) + + \delta \mathrm{tr} \left(B D_B B'\right) + </h:objective> + </h:mini> + <p> + Le gradient peut donc s'écrire : + </p> + <h:equation> + 2 \left(\alpha V'(JVB - JY) + \beta V'LVB + \delta D_B B\right) + </h:equation> + <p> + La fonction objectif est encore convexe par rapport + à <h:eq>B</h:eq>, et la fonction de gradient est aussi + Lipschitzienne, de constante : + </p> + <h:equation> + C_B = \alpha \rho (V'JV) + \beta \rho (L) \rho (V'V) + \delta \max (D_B) + </h:equation> + <p> + Une itération de descente de gradient de pas <h:eq>\frac 1 + {C_B}</h:eq> permet donc de diminuer la fonction de coût. + </p> + <h3>Algorithme final</h3> + <p> + L'algorithme complet <h:ref href="#algorithme-rsms"/> consiste + simplement à alterner les étapes d'optimisation jusqu'à + convergence. On remarque que le calcul du pas d'apprentissage + nécessite d'obtenir la plus grande valeur propre de certaines + matrices : <h:eq>BB'</h:eq> de dimension <h:eq>m \times + m</h:eq>, <h:eq>V'V</h:eq> de dimension <h:eq>o \times o</h:eq>, + et <h:eq>X'X</h:eq> de dimension <h:eq>d \times d</h:eq> (dans + le cas de la sélection de variables, <h:eq>d</h:eq> peut être + grand) et <h:eq>L</h:eq> de dimension <h:eq>N \times N</h:eq> + (pour un problème d'apprentissage semi-supervisé, <h:eq>N</h:eq> + peut être grand). Heureusement, le calcul pour ces deux + dernières matrices peut être fait en amont. + </p> + <h:algorithm id="algorithme-rsms"> + <alg:algorithmic> + <alg:donnée><h:eq>X \in \mathbb{R}^{N, d}</h:eq></alg:donnée> + <alg:donnée><h:eq>J</h:eq>, diagonale, indicatrice des données labellisées</alg:donnée> + <alg:donnée><h:eq>Y \in \mathbb{R}^{N, m}</h:eq></alg:donnée> + <alg:hyperparamètre> + <h:eq>\alpha > 0</h:eq>, + <h:eq>\beta > 0</h:eq>, + <h:eq>\gamma > 0</h:eq>, + <h:eq>\delta > 0</h:eq> + </alg:hyperparamètre> + <alg:hyperparamètre><h:eq>o \in \{1, ..., m\}</h:eq></alg:hyperparamètre> + <alg:hyperparamètre> + matrice Laplacienne du graphe des individus, <h:eq>L \in + \mathbb{R}^{N, N}</h:eq> + </alg:hyperparamètre> + <alg:initialisation> + <alg:state> + <h:eq>B</h:eq> : matrice diagonale rectangulaire + </alg:state> + <alg:state> + <h:eq>W \gets \left[X' J X + \epsilon I\right]^{-1} X'JYB</h:eq> + </alg:state> + <alg:state> + <h:eq>V \gets X W</h:eq> + </alg:state> + <alg:state> + <h:eq>D_W \gets I_{d}</h:eq> + </alg:state> + <alg:state> + <h:eq>D_B \gets I_{m}</h:eq> + </alg:state> + </alg:initialisation> + <alg:itération> + <alg:state> + <h:eq>C_W \gets \rho (X'X) + \gamma \max (D_W)</h:eq> + </alg:state> + <alg:state> + <h:eq>W \gets W - \frac 2 {C_W} (X' (XW - V) + \gamma D_W W)</h:eq> + </alg:state> + <alg:state> + <h:eq>\forall j, \quad {D_W}_{j, j} \gets \frac 1 {2 \left\|W_{j, .}\right\|_2}</h:eq> + </alg:state> + <alg:state> + <h:eq>C_V \gets 1 + \left(\alpha + \beta \rho (L)\right) \rho (BB')</h:eq> + </alg:state> + <alg:state> + <h:eq>V \gets V - \frac 2 {C_V} (V - X W + \alpha JVB' - \alpha JYB' + \beta L V B B')</h:eq> + </alg:state> + <alg:state> + <h:eq>C_B \gets \alpha \rho (V'JV) + \beta \rho (L) \rho (V'V) + \delta \max (D_B)</h:eq> + </alg:state> + <alg:state> + <h:eq>B \gets B - \frac 2 {C_B} (\alpha V'(JVB - JY) + \beta V'LVB + \delta D_B B)</h:eq> + </alg:state> + <alg:state> + <h:eq>\forall l, \quad {D_B}_{l, l} \gets \frac 1 {2 \left\|B_{., l}\right\|_2}</h:eq> + </alg:state> + </alg:itération> + <alg:résultat> + les variables sélectionnées sont les lignes + de <h:eq>W</h:eq> de norme minimale + </alg:résultat> + <alg:résultat> + les labels sélectionnés sont les colonnes de <h:eq>B</h:eq> + de norme minimale + </alg:résultat> + </alg:algorithmic> + <figcaption> + Algorithme <strong>RSMS</strong> : sélection de variables + </figcaption> + </h:algorithm> + <h2>Étude expérimentale</h2> + <p> + Pour évaluer la pertinence de notre approche de sélection de + variables et de labels, nous proposons une étude expérimentale + qui met en concurrence <strong>RSMS</strong>, <emph>SFUS</emph> + <h:cite href="sfus"/>, <emph>RFS</emph> <h:cite href="rfs"/> + et <emph>MIFS</emph> <h:cite href="mifs"/>. + </p> + <p> + L'algorithme <emph>MIFS</emph> est l'algorithme sur lequel nous + nous sommes fondés. Il reprend la sélection de variables + multi-labels semi-supervisée pour la régression + <h:ref href="#rappel-mifs"/>, et son optimisation est également + effectuée par descente de gradient alternée. + </p> + <h:mini id="rappel-mifs"> + <h:variables> + W \in \mathbb{R}^{d, o}, + V \in \mathbb{R}^{n, o}, + B \in \mathbb{R}^{o, m} + </h:variables> + <h:objective> + \left\|XW - V\right\|_F^2 + + \alpha \left\|Y - VB\right\|_F^2 + + \beta \mathrm{tr} \left(V'LV\right) + + \gamma \left\|W\right\|_{2, 1} + </h:objective> + </h:mini> + <p> + L'algorithme RFS utilise la norme <h:eq>l_{2, 1}</h:eq> + exclusivement dans la fonction objectif. Ceci permet d'ignorer + certains individus pour la construction du + modèle <h:eq>W</h:eq>. Si le jeu de données contient des + anomalies, la sélection de variables est rendue plus robuste de + ce point de vue, d'où son nom, <emph>Robust Feature + Selection</emph>. + </p> + <h:mini id="rappel-rfs"> + <h:variables> + W \in \mathbb{R}^{d, m} + </h:variables> + <h:objective> + \left\|XW - Y\right\|_{2, 1}^2 + + \alpha \left\|W\right\|_{2, 1} + </h:objective> + </h:mini> + <p> + Enfin, l'algorithme <emph>SFUS</emph> se fonde sur l'idée de + <emph>RFS</emph>, à savoir l'utilisation de la + norme <h:eq>l_{2,1}</h:eq> pour pouvoir ignorer certains + individus, et une décomposition de rang faible du modèle. + </p> + <h:mini id="rappel-sfus"> + <h:variables> + W \in \mathbb{R}^{d, m}, + P \in \mathbb{R}^{o, m}, + Q \in \mathbb{R}^{d, o} + </h:variables> + <h:objective> + \left\|XW - Y\right\|_{2, 1}^2 + + \alpha \left\|W\right\|_{2, 1} + + \beta \left\|W - QP\right\|_F^2 + </h:objective> + <h:add-constraint> + <h:left>Q'Q = I</h:left> + </h:add-constraint> + </h:mini> + <h3>Jeux de données utilisées</h3> + <p> + Les jeux de données utilisés sont les suivants + <h:cite href="spyromitros_xioufis_multi_target_2016,sarcos"/> : + <emph>atp1d</emph>, + <emph>atp7d</emph>, + <emph>edm</emph>, + <emph>enb</emph>, + <emph>oes10</emph>, + <emph>oes97</emph>, + <emph>osales</emph>, + <emph>scpf</emph>, + <emph>sf1</emph>, + <emph>sf2</emph>, + <emph>wq</emph>, + + comme pour le test de l'algorithme <emph>LSMR</emph> défini dans + le chapitre précédent. + </p> + <h3>Algorithmes utilisés</h3> + <p> + Pour cette étude expérimentale, nous avons sélectionné quatre + algorithmes de sélection de variables multi-labels. + </p> + <p> + Premièrement, l'algorithme <emph>MIFS</emph>. Cet algorithme + n'est pas conçu pour l'apprentissage semi-supervisé ; cependant + sa fonction objectif ainsi que son algorithme d'optimisation + peuvent très simplement utiliser l'information de tous les + individus, y compris ceux non labellisés. C'est cette version + que nous avons utilisée pour la comparaison. À cet algorithme, + nous ajoutons deux algorithmes de sélection de variables + multi-labels, l'algorithme <emph>SFUS</emph> + <h:cite href="sfus"/> et l'algorithme <emph>RFS</emph> + <h:cite href="rfs"/> décrit ci-dessus. + </p> + <p> + Puisque notre approche est destinée à effectuer de la sélection + de variables, nous devons tester les performances d'un + algorithme de régression multi-labels quelconque qui apprendrait + avec différents sous-ensembles des variables (et éventuellement + des labels) sélectionnés. Étant donné qu'il faille effectuer un + apprentissage différent pour chaque sous-ensemble de variables + et chaque sous-ensemble de labels, sans possibilité de + réutilisation des valeurs des hyperparamètres, nous avons choisi + l'algorithme avec un tuning plus limité. Par conséquent, les + valeurs obtenues ne sont pas exactement les mêmes que pour le + chapitre précédent. + </p> + <h3>Protocole expérimental</h3> + <p> + Pour chaque algorithme et chaque jeu de données, on recherche + les valeurs optimales des hyperparamètres en suivant une + procédure de tuning optimisant la valeur moyenne de la métrique + <emph>aRMSE</emph> selon une validation croisée à 10 folds. Une fois ces + hyperparamètres déterminés, les variables (et dans le cas de + <strong>RSMS</strong>, les labels) sont triés par ordre + d'importance. + </p> + <p> + L'évaluation de la sélection de variables s'effectue de la façon + suivante. Pour une certaine fraction de variables, pour chaque + algorithme, on détermine les valeurs des hyperparamètres de + l'algorithme d'évaluation <emph>LSMR</emph> en suivant une + recherche aléatoire qui minimise l'erreur aRMSE moyenne sur les + 10 folds de la validation croisée. La partie de test réservée + pour chaque jeu de données permet d'évaluer + l'algorithme <emph>LSMR</emph>. Le nombre d'individus labellisés + est fixé à 30%. L'opération est répétée 10 fois avec différents + ensembles de test et différents individus labellisés. + </p> + <h3>Évaluation de la sélection de variables</h3> + <p> + Nous avons tout d'abord étudié la performance de la sélection de + variables pour les différents algorithmes sur les différents + jeux de données. En fixant le nombre de labels conservés à 100%, + et le nombre d'individus labellisés à 30%, on obtient une courbe + pour chaque jeu de données, pour la métrique aRMSE + <h:ref href="#fig-rsms_1"/>. + </p> + <p> + Les résultats sont agrégés dans la table + <h:ref href="#tbl-rsms-evaluation-agrege"/>. Nous avons pour + chaque jeu de données, chaque algorithme, et chaque pourcentage + de variables conservées, calculé le rang de chaque algorithme + (entre 1 et 4). Nous montrons le rang moyen de chaque approche + sur l'ensemble des pourcentages de variables sélectionnées. + </p> + <table latex-align="l|cccc"> + <caption id="tbl-rsms-evaluation-agrege"> + Rang moyen de <emph>LSMR</emph> après sélection de variables + multi-labels + </caption> + <thead> + <tr> + <th>Jeu de données</th> + <th><strong>RSMS</strong></th> + <th><emph>MIFS</emph></th> + <th><emph>SFUS</emph></th> + <th><emph>RFS</emph></th> + </tr> + </thead> + <tbody> + <tr> + <td>atp1d</td> + <td><strong>1.9 [1]</strong></td> + <td>2.1 [2]</td> + <td>3.2 [4]</td> + <td>2.8 [3]</td> + </tr> + <tr> + <td>atp7d</td> + <td>2.5 [2]</td> + <td>3.2 [4]</td> + <td><strong>1.3 [1]</strong></td> + <td>3.0 [3]</td> + </tr> + <tr> + <td>edm</td> + <td><strong>1.8 [1]</strong></td> + <td>3.2 [4]</td> + <td>2.3 [2]</td> + <td>2.7 [3]</td> + </tr> + <tr> + <td>enb</td> + <td>2.3 [2]</td> + <td>3.4 [4]</td> + <td><strong>1.8 [1]</strong></td> + <td>2.5 [3]</td> + </tr> + <tr> + <td>oes10</td> + <td>2.8 [3]</td> + <td>2.2 [2]</td> + <td>3.0 [4]</td> + <td><strong>2.0 [1]</strong></td> + </tr> + <tr> + <td>oes97</td> + <td>2.5 [3]</td> + <td>3.6 [4]</td> + <td><strong>1.8 [1]</strong></td> + <td>2.1 [2]</td> + </tr> + <tr> + <td>osales</td> + <td>2.8 [4]</td> + <td>2.0 [2]</td> + <td><strong>1.25 [1]</strong></td> + <td>2.4 [3]</td> + </tr> + <tr> + <td>scpf</td> + <td><strong>2.1 [1]</strong></td> + <td>2.4 [2]</td> + <td>3.1 [4]</td> + <td>2.4 [3]</td> + </tr> + <tr> + <td>sf1</td> + <td><strong>1.9 [1]</strong></td> + <td>2.7 [3]</td> + <td>3.4 [4]</td> + <td>2.0 [3]</td> + </tr> + <tr> + <td>sf2</td> + <td>2.3 [2.5]</td> + <td><strong>1.7 [1]</strong></td> + <td>3.7 [4]</td> + <td>2.3 [2.5]</td> + </tr> + <tr> + <td>wq</td> + <td><strong>1.7 [1]</strong></td> + <td>2.6 [3]</td> + <td>2.4 [2]</td> + <td>3.3 [4]</td> + </tr> + </tbody> + </table> + <p> + Si l'on calcule le rang moyen de chaque algorithme sur toutes + les fractions de variables sélectionnées et tous les jeux de + données, on obtient le résultat suivant : + </p> + <ol> + <li><strong>RSMS</strong> : <strong>2.21</strong></li> + <li><emph>RFS</emph> : 2.50</li> + <li><emph>SFUS</emph> : 2.55</li> + <li><emph>MIFS</emph> : 2.70</li> + </ol> + <figure> + <img src="images/rsms_1.svg" /> + <figcaption id="fig-rsms_1"> + Évaluation de la sélection de variables par <emph>LSMR</emph> + </figcaption> + </figure> + <p> + La figure <h:ref href="#fig-rsms_1"/> montre les résultats + obtenus pour chaque jeu de données. On observe les faits + suivants : + </p> + <ul> + <li> + Pour <emph>atp1d</emph>, + <emph>atp7d</emph>, + <emph>edm</emph>, + <emph>enb</emph>, + <emph>scpf</emph> et <emph>sf1</emph>, la courbe d'erreur a un + minimum global en ne sélectionnant qu'un certain nombre de + variables. Pour <emph>edm</emph>, le choix de la première + variable sélectionnée est très important. + </li> + <li> + Pour <emph>oes10</emph>, + <emph>oes97</emph>, + <emph>sf2</emph> et <emph>wq</emph>, la sélection de variables + n'est pas pertinente puisque l'erreur minimale s'obtient en + sélectionnant toutes les variables, quelle que soit l'approche + étudiée. + </li> + <li> + Pour <emph>osales</emph>, la sélection de variables est très + mauvaise pour RSMS. Pour les autres jeux de données pour + lesquels la sélection de variables est + pertinente, <emph>atp1d</emph>, <emph>atp7d</emph>, + <emph>edm</emph>, et <emph>enb</emph> obtiennent le minimum + global avec <strong>RSMS</strong>. <emph>sf1</emph> observe le + minimum global avec <emph>RFS</emph>, et <emph>scpf</emph> + avec <emph>MIFS</emph> (0.9575 pour <emph>MIFS</emph> contre + 0.9581 pour <strong>RSMS</strong>). + </li> + </ul> + <h3>Sélection de labels</h3> + <p> + Pour la sélection de labels, nous cherchons à observer quels + sont les labels qui sont les plus faciles à apprendre. Pour ce + faire, on garde 30% des variables pour l'apprentissage, et on + évalue la performance de l'algorithme <emph>LSMR</emph> en ne + conservant que 20%, 40%, 60%, 80% et 100% des labels. + </p> + <figure> + <img src="images/rsms_2.svg" /> + <figcaption id="fig-rsms_2"> + Évaluation de la sélection de labels de <strong>RSMS</strong> + par <emph>LSMR</emph> + </figcaption> + </figure> + <p> + La figure <h:ref href="#fig-rsms_2"/> montre la courbe de + sélection de labels pour chaque jeu de données. On retrouve + différent cas de figure : + </p> + <ul> + <li> + Pour <emph>atp1d</emph>, <emph>atp7d</emph>, <emph>enb</emph>, + <emph>osales</emph> et <emph>wq</emph>, la sélection de label + permet de trouver un nombre de labels pour lequel l'erreur est + minimale, de sorte qu'en sélectionnant moins de labels + l'erreur augmente et en en sélectionnant plus l'erreur + augmente également. + </li> + <li> + Pour <emph>oes10</emph>, <emph>scpf</emph> + et <emph>sf1</emph>, l'erreur est minimale si l'on ne garde + que le nombre minimum de labels. + </li> + <li> + Pour <emph>edm</emph>, <emph>oes97</emph> et <emph>sf2</emph>, + sélectionner tous les labels donne une erreur de régression + plus faible. + </li> + </ul> + <h3>Sélection de labels au service de la sélection de variables</h3> + <p> + Concrètement, si certains labels ne peuvent pas être bien + expliqués globalement par les variables en jeu, ils sont + simplement ignorés dans la sélection de variables. Dans ce cas, + nous comparons le résultat de l'apprentissage en conservant 80% + des labels, contre le résultat pour 100% des labels. Dans le cas + où le jeu de données a moins de 5 labels, on en conserve moins, + pour observer une différence : + </p> + <ul> + <li>pour <emph>edm</emph> et <emph>enb</emph>, on ne conserve + qu’un label ;</li> + <li>pour <emph>scpf</emph>, <emph>sf1</emph> + et <emph>sf2</emph>, on en conserve 2 ;</li> + </ul> + <figure> + <img src="images/rsms_3.svg" /> + <figcaption id="fig-rsms_3"> + Comparaison de la sélection de variables pour tous les labels, + et pour un nombre restreint de labels + </figcaption> + </figure> + <p> + La figure <h:ref href="#fig-rsms_3"/> montre la différence entre + la sélection de variables seule et la sélection de variables + avec sélection de labels. Les courbes obtenues indiquent + qu'éliminer 20% des labels donne une meilleure erreur de + régression. Les exceptions sont <emph>enb</emph>, d'une part, + et <emph>oes10</emph>, <emph>oes97</emph> et <emph>sf2</emph> + d'autre part, pour lesquels la sélection de variables n'est tout + simplement pas pertinente. Le fait que les courbes semblent + simplement translatées en sélectionnant les labels, sans changer + la position du minimum, indique que les variables sélectionnées + ne sont pas pertinentes pour les labels ignorés, ce qui était le + but de notre approche. + </p> + <h3>Convergence de l'algorithme</h3> + <p> + Dans cette section, nous vérifions expérimentalement que notre + approche converge en 100 itérations, ce qui est utilisé pour + l'obtention de l'ordre des variables et des labels, comme + utilisé dans les deux sections précédentes. + </p> + <figure> + <img src="images/rsms_4.svg" /> + <figcaption id="fig-rsms_4"> + Courbes de convergence de l'algorithme de sélection de + variables *RSMS* avec écart-type + </figcaption> + </figure> + <p> + La figure <h:ref href="#fig-rsms_4"/> montre les résultats + obtenus pour chaque jeu de données. On observe les faits + suivants : + </p> + <ul> + <li>La méthode converge en moins de 100 itérations.</li> + <li>La convergence s'observe entre 10 itérations + (pour <emph>osales</emph>) et 50 itérations + (pour <emph>wq</emph>)</li> + <li>Pour les jeux de données <emph>sf1</emph> + et <emph>sf2</emph>, la convergence s'opère très rapidement, + mais la fonction de coût reste importante.</li> + </ul> + <h2>Conclusion</h2> + <p> + Dans ce chapitre, nous avons proposé un algorithme de sélection + de variables pour la régression multi-labels en mode + semi-supervisée. Nous avons utilisé l'hypothèse selon laquelle + la sélection de labels peut être au service de la sélection de + variables. + </p> + <p> + Nous avons montré expérimentalement que notre approche est + compétitive avec l'état de l'art de sélection de variables en + régression multi-labels. Nous avons également montré la + pertinence de la sélection de labels, pour déduire les labels + dont l'apprentissage est plus facile, ce qui guide la sélection + de variables à superformer davantage. + </p> + <h1 short="Application"> + Application à l’annotation automatique de pneumatiques + </h1> + <h:résumé-chapitre> + <p> + Dans ce chapitre, nous présentons le cadre d'annotation + automatique que nous avons développé pour notre partenaire + industriel Lizeo IT. Dans le cadre de cette thèse, nous sommes + confrontés à un problème réel nécessitant un apprentissage + semi-supervisé multi-labels. Nous évaluons la batterie + d'algorithmes développés pour les deux tâches principales, à + savoir la régression et la sélection de variables. Nous + proposons également une adaptation de ces algorithmes afin de + traiter le problème dans le cas où le nombre d'individus est + important. + </p> + </h:résumé-chapitre> + <h2>Introduction</h2> + <p> + Étant dans le cadre d'une convention CIFRE, cette thèse doit + proposer un bon compromis entre l'aspect fondamental développé + dans les chapitres précédents et l'aspect applicatif en validant + nos modèles sur les jeux de données de l'entreprise. Ces données + sont de nature textuelle et définissent différentes + caractéristiques sur les pneumatiques. + </p> + <h2>Présentation de l’entreprise</h2> + <p> + Le cœur de métier du groupe international Lizeo (et de ses + filiales aux États-Unis, à Shanghai et à Lyon) consiste à + étudier les données relatives à l'industrie automobile, et en + particulier les pneumatiques. L'activité de Lizeo se décompose + en deux axes : + </p> + <ul> + <li> + l'activité <emph>B2B</emph> (<emph>Business to + Business</emph>), qui consiste à traiter des données telles + que les caractéristiques techniques, les prix, les + évaluations, voire les photos et descriptions, à destination + des entreprises s'intéressant au marché du pneumatique, + </li> + <li> + l'activité <emph>B2C</emph> (<emph>Business to + Consumer</emph>), en particulier représentée par son site + vitrine <a href="http://pneu.rezulteo.fr">http://pneu.rezulteo.fr</a>, + un comparateur de pneumatiques à destination du public. + </li> + </ul> + <p> + Parmi l'ensemble des données dont dispose Lizeo IT, nous + retrouvons (cf figure <h:ref href="#fig-lizeo-donnees"/>) : + </p> + <ul> + <li> + des produits, c'est-à-dire des pneumatiques, avec leurs + caractéristiques techniques, les résultats des tests, ou les + évaluations d'experts ; + </li> + <li> + des prix, collectés auprès des revendeurs ou par aspiration de + sites vendeurs ; + </li> + <li> + des données de véhicules associées aux pneumatiques ; + </li> + <li> + des données des distributeurs, qui permettent notamment de les + identifier et les localiser ; + </li> + <li> + et enfin, ce qui nous intéresse tout particulièrement, des + avis des consommateurs, présents sur des forums, et les média + sociaux. + </li> + </ul> + <figure> + <img src="images/lizeo-donnees.png" /> + <figcaption id="fig-lizeo-donnees"> + Résumé des données collectées par Lizeo dans le cadre de son + activité (communication interne) + </figcaption> + </figure> + <p> + Les travaux actuels de l'équipe R&D du groupe portent sur + différents thèmes : + </p> + <ul> + <li> + l'analyse textuelle des avis du public et des experts des + produits, dont cette thèse fait partie, mais qui vise aussi à + la découverte automatique de thématiques ; + </li> + <li> + l'analyse du cycle de vie des produits à partir des volumes de + prix aspirés sur les sites de vente en ligne, afin de savoir + si un pneumatique est récent, ou plus utilisé ; + </li> + <li> + l'analyse des prix des produits, avec en particulier la + détection d'anomalies dans les séries temporelles, afin de + détecter les problèmes dans l'aspiration des prix des + pneumatiques sur le web (ce qui est préjudiciable pour un + comparateur de pneumatiques) ; + </li> + <li> + la prédiction de volumes marchés et de prix. + </li> + </ul> + <h2>Description du jeu de données</h2> + <p> + L'entreprise Lizeo IT, dans le cadre de son activité B2B, + propose d'effectuer une veille des pneumatiques dans des + ressources sur le web, telles que des forums, des articles + spécialisés et des tweets. Concrètement, chaque document est un + texte, la plupart étant plutôt courts (note de forum ou tweet), + traitant d'un ou de plusieurs produits. + </p> + <p> + L'analyse de ces documents est cruciale pour Lizeo. La + perception qu'ont les consommateurs des produits est une donnée + d'importance, tant pour les manufacturiers que pour les + distributeurs. + </p> + <p> + On peut décrire chaque produit à partir de différentes + caractéristiques, appelées <emph>qualifier</emph> dans le jeu de + données. Les experts ont identifié de + nombreux <emph>qualifier</emph>. On peut par exemple citer le + prix du produit, le bruit, la tenue sur route, ainsi que + des <emph>qualifier</emph> plus précis : la tenue sur route + humide, ou enneigée. Les <emph>qualifier</emph> sont ainsi + conçus comme une hiérarchie. Il y a de + nombreux <emph>qualifier</emph> dans le jeu de données, mais + nous avons retenu les 97 qui sont employés plus de 10 fois. + </p> + <p> + Pour un document donné à propos d'un certain produit, un premier + objectif du traitement consiste à indiquer, pour chaque + <emph>qualifier</emph>, si celui-ci est pertinent. Concrètement, + si le document comporte un commentaire sur le bruit d'un + produit, il faut indiquer le <emph>qualifier</emph> "bruit". + </p> + <p> + Ce problème se traduit en un problème d'apprentissage de + classification multi-labels : l'unité statistique est le + document, les variables descriptives sont des variables + textuelles, et les labels (binaires) sont + les <emph>qualifier</emph>. Ce problème de classification, + résumé par la figure <h:ref href="#fig-lizeo-classification"/>, + n'est cependant pas notre objectif principal. + </p> + <figure> + <img src="images/lizeoclassif.svg" /> + <figcaption id="fig-lizeo-classification"> + Première étape du traitement du jeu de données Lizeo IT : + apprentissage de classification binaire multi-labels + </figcaption> + </figure> + <p> + Si un <emph>qualifier</emph> est pertinent pour un certain + produit de l'un des documents, la question qui nous intéresse + est la suivante : les termes employés évoquent-ils ce qualifier + d'une façon positive ou péjorative ? Nous définissons pour cela + la <emph>tonalité</emph> d'une qualification d'un document comme + un nombre réel. Une valeur positive de la tonalité indique un + sentiment positif. Une valeur nulle indique un sentiment neutre, + et une valeur négative un sentiment négatif. Nous traitons ce + problème par un apprentissage de régression multi-labels, figure + <m:ref href="#fig-lizeoreg"/>. + </p> + <figure> + <img src="images/lizeoreg.svg" /> + <figcaption id="fig-lizeoreg"> + Apprentissage de régression multi-labels de la tonalité + </figcaption> + </figure> + <h2>Traitement des données textuelles</h2> + <p> + Dans le jeu de données utilisé, il se peut qu'il y ait une + comparaison entre deux produits sur les mêmes critères. Dans ce + cas, on ne verra que la moyenne pour l'apprentissage. Ceci donne + parfois des valeurs non entières pour les labels. + </p> + <p> + Afin d'évaluer les performances de la sélection de variables et + de la sélection de labels, nous étudions un sous-ensemble des + données regroupant les caractéristiques suivantes : + </p> + <ol> + <li>Il s'agit de documents (appelés parfois posts) en français ;</li> + <li>Les documents sont tous labellisés ;</li> + <li>Il y a 84 907 documents ;</li> + <li> + La distribution du nombre de /qualifiers/ est documentée par + la table <h:ref href="#tbl-distrib-qualifiers-restreint"/>. On + constate qu'il y a 30 145 documents associés à aucun + qualifier, il ne s'agit pourtant pas d'individus non + labellisés, car nous savons qu'aucun des critères retenus ne + s'applique sur ces documents. Dans notre cadre de régression, + ceci signifie que toutes les tonalités doivent être neutres ; + </li> + <li> + Les 10 qualifiers les plus fréquents sont résumés dans la + table <h:ref href="#tbl-summary-frequent-qualifiers"/>, ce qui + correspond à 69% de toutes les qualifications. + </li> + </ol> + <table latex-align="rr"> + <caption id="tbl-distrib-qualifiers-restreint"> + Distribution du nombre de qualifiers par document + </caption> + <thead> + <tr> + <th>Nombre de <emph>qualifiers</emph></th> + <th>Nombre de documents</th> + </tr> + </thead> + <tbody> + <tr><td>0</td><td>30145</td></tr> + <tr><td>1</td><td>31723</td></tr> + <tr><td>2</td><td>12372</td></tr> + <tr><td>3</td><td>5350</td></tr> + <tr><td>4</td><td>2710</td></tr> + <tr><td>5</td><td>1321</td></tr> + <tr><td>6</td><td>653</td></tr> + <tr><td>7</td><td>310</td></tr> + <tr><td>8</td><td>160</td></tr> + <tr><td>9</td><td>89</td></tr> + <tr><td>10</td><td>48</td></tr> + <tr><td>Entre 11 et 37</td><td>53</td></tr> + </tbody> + </table> + <p> + Les labels ont une arborescence. On retrouve : + </p> + <ul> + <li>la réputation d'un produit ;</li> + <li>l’usure ;</li> + <li>la satisfaction du consommateur ;</li> + <li> + la sécurité, en évaluant la traction sur route sèche, humide + ou enneigée ; + </li> + <li>le prix ;</li> + <li>le confort ;</li> + <li>et même l'esthétique du produit.</li> + </ul> + <table latex-align="rrlrr"> + <caption id="tbl-summary-frequent-qualifiers"> + Résumé des qualifieurs les plus fréquents parmi les 97 + (<emph>Cons. feedback</emph> est l'abréviation + de <emph>Consumer feedback</emph>, retour client, + et <emph>sat.</emph> de <emph>satisfaction</emph>). + </caption> + <thead> + <tr> + <th>N<sup>o</sup></th> + <th>Nombre</th> + <th>Nom</th> + <th>Médiane</th> + <th>Moyenne</th> + </tr> + </thead> + <tbody> + <tr> + <td>59</td> + <td>31.82%</td> + <td>Characteristics / Image / Reputation</td> + <td>-1.000</td> + <td>-0.598</td> + </tr> + <tr> + <td>483</td> + <td>25.07%</td> + <td>Performances / Wear life / Wear life</td> + <td>0.000</td> + <td>-0.198</td> + </tr> + <tr> + <td>52</td> + <td>19.41%</td> + <td>Performances / Cons. feedback / Overall sat.</td> + <td>-1.000</td> + <td>-0.936</td> + </tr> + <tr> + <td>549</td> + <td>11.07%</td> + <td>Performances / Safety / Traction</td> + <td>-0.750</td> + <td>-0.538</td> + </tr> + <tr> + <td>506</td> + <td>7.99%</td> + <td>Performances / Ride performance / Noise</td> + <td>0.000</td> + <td>-0.163</td> + </tr> + <tr> + <td>494</td> + <td>7.68%</td> + <td>Performances / Safety / Handling</td> + <td>-1.000</td> + <td>-0.579</td> + </tr> + <tr> + <td>780</td> + <td>6.95%</td> + <td>Performances / Safety / Wet traction</td> + <td>-0.500</td> + <td>-0.419</td> + </tr> + <tr> + <td>782</td> + <td>5.72%</td> + <td>Performances / Safety / Snow/Winter traction</td> + <td>-0.667</td> + <td>-0.582</td> + </tr> + <tr> + <td>495</td> + <td>5.30%</td> + <td>Performances / Safety / Steering</td> + <td>0.000</td> + <td>-0.090</td> + </tr> + <tr> + <td>61</td> + <td>4.78%</td> + <td>Characteristics / Image / Intent to purchase</td> + <td>-1.000</td> + <td>-0.583</td> + </tr> + <tr> + <td>21</td> + <td>4.11%</td> + <td>Performances / Safety / Safety</td> + <td>-0.333</td> + <td>-0.386</td> + </tr> + <tr> + <td>60</td> + <td>3.87%</td> + <td>Characteristics / Image / Test results</td> + <td>-0.333</td> + <td>-0.572</td> + </tr> + <tr> + <td>491</td> + <td>3.61%</td> + <td>Performances / Environment / Environment</td> + <td>0.000</td> + <td>-0.473</td> + </tr> + <tr> + <td>58</td> + <td>3.49%</td> + <td>Performances / Cons. feedback / Recommendation</td> + <td>-1.000</td> + <td>-0.720</td> + </tr> + <tr> + <td>781</td> + <td>3.12%</td> + <td>Performances / Safety / Dry traction</td> + <td>-1.000</td> + <td>-0.831</td> + </tr> + <tr> + <td>132</td> + <td>3.03%</td> + <td>Attitude / Towards tyre type</td> + <td>-0.500</td> + <td>-0.389</td> + </tr> + <tr> + <td>488</td> + <td>2.55%</td> + <td>Performances / Wear life / Abnormal Wear</td> + <td>1.000</td> + <td>0.525</td> + </tr> + <tr> + <td>487</td> + <td>2.37%</td> + <td>Performances / Toughness/Robustness / <emph><idem></emph></td> + <td>0.000</td> + <td>-0.055</td> + </tr> + <tr> + <td>10</td> + <td>2.23%</td> + <td>Characteristics / Price / Value for money</td> + <td>-1.000</td> + <td>-1.014</td> + </tr> + <tr> + <td>484</td> + <td>2.16%</td> + <td>Performances / Wear life / Ageing</td> + <td>0.000</td> + <td>0.404</td> + </tr> + <tr> + <td>497</td> + <td>2.12%</td> + <td>Performances / Safety / Stopping distance</td> + <td>0.000</td> + <td>-0.390</td> + </tr> + <tr> + <td>489</td> + <td>2.01%</td> + <td>Characteristics / Price / Deal / Discount</td> + <td>-1.000</td> + <td>-0.573</td> + </tr> + <tr> + <td>558</td> + <td>2.00%</td> + <td>Performances / Track/Sport perf. / Track perf.</td> + <td>0.000</td> + <td>-0.474</td> + </tr> + <tr> + <td>504</td> + <td>1.92%</td> + <td>Performances / Ride perf. / Ride experience</td> + <td>-1.000</td> + <td>-0.616</td> + </tr> + <tr> + <td>505</td> + <td>1.65%</td> + <td>Performances / Ride perf. / Ride comfort</td> + <td>-0.500</td> + <td>-0.440</td> + </tr> + <tr> + <td>133</td> + <td>1.33%</td> + <td>Attitude / Towards tests</td> + <td>0.000</td> + <td>-0.288</td> + </tr> + <tr> + <td>784</td> + <td>1.31%</td> + <td>Performances / Safety / Off road traction</td> + <td>-0.667</td> + <td>-0.546</td> + </tr> + <tr> + <td>508</td> + <td>1.29%</td> + <td>Characteristics / Image / Look/aesthetic</td> + <td>0.000</td> + <td>-0.352</td> + </tr> + </tbody> + </table> + <p> + La table <h:ref href="#tbl-summary-frequent-qualifiers"/> permet + de faire la remarque suivante : pour les qualifieurs les plus + fréquents, la moyenne est souvent négative, et la médiane n'est + jamais positive. Le fait que la médiane ne soit pas toujours + entière tient aux posts faisant une comparaison de plusieurs + produits, comme expliqué plus haut. + </p> + <h2>Application de l'algorithme LSMR</h2> + <p> + Dans le cadre de cette application, nous sommes confrontés à un + jeu de données réel, ce qui pose de nouvelles contraintes. Pour + appliquer l'algorithme <emph>LSMR</emph>, nous avons dû + effectuer des adaptations de celui-ci afin de pouvoir + fonctionner dans un cas où le nombre + d'individus, <h:eq>N</h:eq>, est très grand. En effet, + l'application de l'algorithme <emph>LSMR</emph> demande une + décomposition en valeurs propres et vecteurs propres (partielle) + de la matrice noyau, <h:eq>K</h:eq>, de dimension <h:eq>N \times + N</h:eq>. Dans ce cas, on peut appliquer l'algorithme de Lanczos + <h:cite href="lanczos"/>, qui permet d'obtenir le résultat avec + une complexité de <h:eq>\mathcal{O} (s N ^ 2)</h:eq>. La + complexité spatiale, de manière bien plus prosaïque, est + déterminée par la construction et le stockage de la matrice + Laplacienne du graphe, <h:eq>L</h:eq>, et de la matrice noyau, + <h:eq>K</h:eq>, toutes deux de dimension <h:eq>N \times + N</h:eq>. + </p> + <p> + Afin de pouvoir effectuer une approximation de l'apprentissage + en un temps raisonnable, nous proposons une modification + ensembliste de l'algorithme <emph>LSMR</emph> adaptée à ce jeu + de données. + </p> + <h3>Méthode ensembliste : Bootstrap Aggregating</h3> + <p> + Afin de conserver une valeur de <h:eq>N</h:eq> acceptable, nous + tirons 20 différents sous-ensembles de 4000 points du jeu de + données avec remise, afin d'obtenir 20 jeux de données + différents de taille plus faible. Cette méthode est nommée + <emph>Bootstrap Aggregating</emph>, ou <emph>Bagging</emph> + <h:cite href="Breiman1996"/>. + </p> + <p> + Comme notre algorithme nécessite un certain nombre + d'hyperparamètres, nous considérons un sous-ensemble de + validation en plus des 4000 points pour le jeu + d'apprentissage. La métrique de validation <emph>aRMSE</emph> + est calculée pour chaque modèle, ce qui nous permet de + sélectionner les 10 candidats donnant la meilleure erreur de + régression. + </p> + <h3>Stacking</h3> + <p> + La méthode de <emph>bagging</emph> prévoit de traiter + l'apprentissage d'un modèle par ensemble. La prédiction pour un + nouvel individu s'effectue en prenant la moyenne de la + prédiction de tous les modèles, dans le cas de la régression. + </p> + <p> + Cette méthode a l'avantage de s'appliquer de manière naturelle dans le + cas de la régression multi-labels. + </p> + <p> + Nous utilisons aussi une deuxième approche d'agrégation, nommée + <emph>stacking</emph> <h:cite href="stacking"/>. Dans cette + approche, on considère un nouveau jeu de données + artificiel. Dans ce jeu de données, l'individu statistique est + toujours le même, mais il est décrit cette fois par les + prédictions de chacun des modèles retenus, et les labels sont + les mêmes que pour le jeu d'apprentissage original. + </p> + <p> + Étant donné le cadre multi-labels de l'apprentissage original, + nous considérons pour l'apprentissage par <emph>stacking</emph> + que les labels à ce stade sont indépendants. Pour chaque label, + on cherche donc à prédire la valeur du label en fonction des + prédictions de tous les modèles pour ce label. + </p> + <p> + Cette étape est également l'occasion de ne considérer dans le + jeu de données que les valeurs pertinentes. En effet, si l'on + revient à la construction du jeu de données, et si un + <emph>qualifier</emph> (label) n'est pas présent, la valeur + cible sera la valeur neutre, 0. Cependant, cette valeur n'est + pas vraiment pertinente pour l'apprentissage, ce qui pousse le + modèle à apprendre des valeurs faibles. Les prédictions sont + donc naturellement de norme inférieure à la vérité terrain. Pour + compenser ce biais, l'agrégation par label ne retient comme + individus que les posts présentant le <emph>qualifier</emph> en + question. + </p> + <p> + Enfin, pour éviter le sur-apprentissage, on ne considère pour + chaque modèle que les individus n'ayant pas servi à + l'apprentissage du modèle de <emph>bootstrap</emph>. Pour les + tâches de <emph>stacking</emph>, les valeurs de prédiction de + chaque modèle sur son jeu d'apprentissage sont remplacées par 0. + </p> + <p> + Le régresseur retenu est une régularisation <emph>ridge</emph>, + dont le régulariseur est recherché comme une puissance de 10 + entre <h:eq>10^{-4}</h:eq> et <h:eq>10^{4}</h:eq>. + </p> + <h3>Résultats</h3> + <p> + En appliquant l'algorithme, sans effectuer de sélection de + variables, on obtient le résultat présenté en table + <h:ref href="#lizeo-lsmr-full"/>. Nous retenons que l'agrégation + par <emph>stacking</emph> avec régularisation Ridge donne un + meilleur résultat que l'agrégation moyenne. + </p> + <table latex-align="rr"> + <caption id="lizeo-lsmr-full"> + Application de l'algorithme <emph>LSMR</emph>, + avec <emph>bootstrap</emph>, toutes les variables, et les deux + agrégations possibles + </caption> + <thead> + <tr> + <th>Agrégation moyenne</th> + <th>Agrégation Ridge</th> + </tr> + </thead> + <tbody> + <tr><td>0.819</td><td>0.809</td></tr> + </tbody> + </table> + <h2>Comparaison d'algorithmes de sélection de variables</h2> + <p> + Afin d'évaluer la sélection de variables, nous avons sélectionné + 20 sous-ensembles de 4000 individus. La valeur des + hyperparamètres est obtenue en minimisant la métrique aRMSE du + modèle final. Nous évaluons deux autres algorithmes de sélection + de variables multi-labels : <emph>RFS</emph> + <h:cite href="rfs"/> et <emph>MIFS</emph> + <h:cite href="mifs"/>. Nous n'avons pas pu tuner et appliquer + l'algorithme <emph>SFUS</emph> en un temps raisonnable, à cause + de la décomposition en valeurs propres et vecteurs propres d'une + matrice <h:eq>d \times d</h:eq>. + </p> + <h3>RFS</h3> + <p> + L'algorithme <emph>RFS</emph> <h:cite href="rfs"/> effectue la + sélection de variables en minimisant le problème suivant : + </p> + <h:mini> + <h:variables> + W \in \mathbb{R}^{d, m} + </h:variables> + <h:objective> + \left\|XW - Y\right\|_{2, 1}^2 + + \gamma \left\|W\right\|_{2, 1} + </h:objective> + </h:mini> + <p> + Ce problème utilise une régularisation <h:eq>l_{2, 1}</h:eq>, + mais utilise aussi cette même norme pour la fonction de + coût. Concrètement, cela permet d'ignorer certains individus + pour la sélection de variables. + </p> + <h3>MIFS</h3> + <p> + Nous utilisons aussi l'algorithme <emph>MIFS</emph> + <h:cite href="mifs"/>, qui est la base de notre approche + proposée. Pour rappel, le problème résolu par <emph>MIFS</emph> + est la minimisation suivante : + </p> + <h:mini> + <h:variables> + \substack{ + W \in \mathbb{R}^{d, o} \\ + V \in \mathbb{R}^{n, o} \\ + B \in \mathbb{R}^{o, m} + } + </h:variables> + <h:objective> + \left\|XW - V\right\|_F^2 + + \alpha \left\|Y - VB\right\|_F^2 + + \beta \mathrm{tr} \left(V'LV\right) + + \gamma \left\|W\right\|_{2, 1} + </h:objective> + </h:mini> + <h3>Sélection de variables : étude préliminaire</h3> + <p> + Pour chaque sous-ensemble d'individus, on obtient une liste + ordonnée de variables. Pour calculer la sélection de variables + finale, nous calculons les rangs moyens de chaque variable pour + chaque algorithme. Les premières variables sont listées dans la + table <h:ref href="#tbl-lizeo-feature-selection"/>. + </p> + <table latex-align="lll"> + <caption id="tbl-lizeo-feature-selection"> + Sélection des 30 premières variables pour chaque algorithme. + </caption> + <thead> + <tr> + <th><strong>RSMS</strong></th> + <th><emph>MIFS</emph></th> + <th><emph>RFS</emph></th> + </tr> + </thead> + <tbody> + <tr> + <td><pre>disponible</pre></td> + <td><pre>classement\_adac</pre></td> + <td><pre>silence</pre></td> + </tr> + <tr> + <td><pre>d'origine</pre></td> + <td><pre>litres</pre></td> + <td><pre>accrochent</pre></td> + </tr> + <tr> + <td><pre>actuels</pre></td> + <td><pre>vii</pre></td> + <td><pre>flottement</pre></td> + </tr> + <tr> + <td><pre>sport</pre></td> + <td><pre>def\_90</pre></td> + <td><pre>bluffé</pre></td> + </tr> + <tr> + <td><pre>hiver</pre></td> + <td><pre>l'emergency</pre></td> + <td><pre>sécurisant</pre></td> + </tr> + <tr> + <td><pre>55</pre></td> + <td><pre>assez\_bon</pre></td> + <td><pre>décroche</pre></td> + </tr> + <tr> + <td><pre>véhicule</pre></td> + <td><pre>remonte</pre></td> + <td><pre>aquaplaning</pre></td> + </tr> + <tr> + <td><pre>malheureusement</pre></td> + <td><pre>90\_cv</pre></td> + <td><pre>regrette</pre></td> + </tr> + <tr> + <td><pre>3</pre></td> + <td><pre>defacyde</pre></td> + <td><pre>azenis</pre></td> + </tr> + <tr> + <td><pre>prix</pre></td> + <td><pre>rapprochement</pre></td> + <td><pre>l'abs</pre></td> + </tr> + <tr> + <td><pre>205</pre></td> + <td><pre>solidité</pre></td> + <td><pre>négatif</pre></td> + </tr> + <tr> + <td><pre>recherche</pre></td> + <td><pre>optimisées</pre></td> + <td><pre>routiers</pre></td> + </tr> + <tr> + <td><pre>r16</pre></td> + <td><pre>dois\_prendre</pre></td> + <td><pre>excellents</pre></td> + </tr> + <tr> + <td><pre>non</pre></td> + <td><pre>extended</pre></td> + <td><pre>pépère</pre></td> + </tr> + <tr> + <td><pre>4</pre></td> + <td><pre>attendant</pre></td> + <td><pre>demi</pre></td> + </tr> + <tr> + <td><pre>r17</pre></td> + <td><pre>l'exige</pre></td> + <td><pre>l'esp</pre></td> + </tr> + <tr> + <td><pre>été</pre></td> + <td><pre>justifie\_pas</pre></td> + <td><pre>soleil</pre></td> + </tr> + <tr> + <td><pre>l'indice</pre></td> + <td><pre>virages\_sans</pre></td> + <td><pre>mou</pre></td> + </tr> + <tr> + <td><pre>235</pre></td> + <td><pre>prévenir</pre></td> + <td><pre>confortables</pre></td> + </tr> + <tr> + <td><pre>215</pre></td> + <td><pre>promener</pre></td> + <td><pre>châssis</pre></td> + </tr> + <tr> + <td><pre>225</pre></td> + <td><pre>financière</pre></td> + <td><pre>catastrophique</pre></td> + </tr> + <tr> + <td><pre>marquage</pre></td> + <td><pre>pas\_1</pre></td> + <td><pre>pourri</pre></td> + </tr> + <tr> + <td><pre>cherche</pre></td> + <td><pre>carcasses</pre></td> + <td><pre>chauffe</pre></td> + </tr> + <tr> + <td><pre>195</pre></td> + <td><pre>écrit\_1</pre></td> + <td><pre>reproche</pre></td> + </tr> + <tr> + <td><pre>45</pre></td> + <td><pre>n'avait\_pas</pre></td> + <td><pre>gain</pre></td> + </tr> + <tr> + <td><pre>65</pre></td> + <td><pre>s\_max</pre></td> + <td><pre>feeling</pre></td> + </tr> + <tr> + <td><pre>vitesse</pre></td> + <td><pre>marketing</pre></td> + <td><pre>fou</pre></td> + </tr> + <tr> + <td><pre>charge</pre></td> + <td><pre>225\_75</pre></td> + <td><pre>d'urgence</pre></td> + </tr> + <tr> + <td><pre>xl</pre></td> + <td><pre>contrainte</pre></td> + <td><pre>savonnette</pre></td> + </tr> + <tr> + <td><pre>svp</pre></td> + <td><pre>moyens</pre></td> + <td><pre>clairement</pre></td> + </tr> + </tbody> + </table> + <p> + Qualitativement, les 30 premières variables indiquent un + avantage pour <emph>RFS</emph>. Les premières variables + sélectionnées par <strong>RSMS</strong> sont principalement des + éléments de dimension, c'est-à-dire des caractéristiques de + forme des pneumatiques, ce qui n'est pas l'objet de notre étude. + </p> + <h3>Évaluation de la sélection de variables</h3> + <p> + Nous pouvons aussi évaluer quantitativement la sélection de + variables. Nous choisissons un sous-ensemble de 4000 points, en + appliquant l'algorithme <emph>LSMR</emph> non modifié, pour + accélérer les calculs. + </p> + <figure> + <img src="images/featureselectionlizeo.svg" /> + <figcaption id="fig-featureselectionlizeo"> + Sélection de variables comparée pour avec LSMR non modifié + comme évaluateur + </figcaption> + </figure> + <p> + En évaluant le résultat de la sélection de variables + (figure <h:ref href="#fig-featureselectionlizeo"/>), on remarque + cependant que c'est bien notre approche qui procure le meilleur + résultat de sélection. En effet, l'erreur de régression est + minimale pour 5% des variables sélectionnées (soit environ 1000 + variables), contrairement à <emph>MIFS</emph> + et <emph>RFS</emph> dont la sélection n'atteint la meilleure + efficacité qu'en sélectionnant toutes les variables. On remarque + aussi que la courbe de <strong>RSMS</strong> est plus abrupte + que les autres, ce qui signifie que la sélection est plus + efficace dès les premières centaines de variables sélectionnées. + </p> + <p> + Nous retenons la valeur des hyperparamètres issus du tuning + pour <strong>RSMS</strong> : + </p> + <ul> + <li>rang : <h:eq>o = 30</h:eq> ;</li> + <li><h:eq>\alpha = 10^{3}</h:eq> ;</li> + <li><h:eq>\beta = 2.5 \times 10^{-2}</h:eq> ;</li> + <li><h:eq>\gamma = 4 \times 10^{6}</h:eq> ;</li> + <li><h:eq>\delta = 4 \times 10^{2}</h:eq>.</li> + </ul> + <h2>Application de <strong>RSMS</strong> sur l'ensemble du jeu de + données</h2> + <p> + Étant donné que le jeu de données contient trop d'individus pour + construire et utiliser la matrice Laplacienne du graphe des + individus, nous considérons une version légèrement modifiée de + l'algorithme. + </p> + <h3>Optimisation par époques</h3> + <p> + Chaque étape de l'algorithme <strong>RSMS</strong> est une + itération de la descente de gradient. Il est possible d'utiliser + la version stochastique avec <emph>minibatch</emph>, + c'est-à-dire qu'au lieu de sélectionner un individu à chaque + itération, un sous-ensemble est sélectionné à la place. Cette + stratégie est souvent employée car elle permet expérimentalement + d'obtenir le résultat en moins d'itération qu'avec la version + stochastique. En contrepartie, le calcul du gradient doit se + faire pour tous les individus sélectionnés simultanément, ce qui + n'est pas un problème pour les architectures de calcul parallèle + modernes <h:cite href="alexnet"/>. + </p> + <p> + Afin de pouvoir réutiliser les matrices Laplacienne de graphe, + le partitionnement est le même à chaque époque. Nous obtenons le + résultat pour 10 époques. + </p> + <h3>Résultats</h3> + <p> + Les premières variables ainsi obtenues sont exposées dans la + table <h:ref href="#tbl-rsms-full-feature-selection"/>. + </p> + <table latex-align="l"> + <caption id="tbl-rsms-full-feature-selection"> + Sélection des 30 premières variables de la sélection de RSMS + par époques + </caption> + <thead> + <tr> + <th><strong>RSMS par époques</strong></th> + </tr> + </thead> + <tbody> + <tr><td><pre>très</pre></td></tr> + <tr><td><pre>pas</pre></td></tr> + <tr><td><pre>content</pre></td></tr> + <tr><td><pre>bon</pre></td></tr> + <tr><td><pre>4</pre></td></tr> + <tr><td><pre>sport</pre></td></tr> + <tr><td><pre>bien</pre></td></tr> + <tr><td><pre>meilleurs</pre></td></tr> + <tr><td><pre>plus</pre></td></tr> + <tr><td><pre>neige</pre></td></tr> + <tr><td><pre>top</pre></td></tr> + <tr><td><pre>nokian</pre></td></tr> + <tr><td><pre>satisfait</pre></td></tr> + <tr><td><pre>prix</pre></td></tr> + <tr><td><pre>trop</pre></td></tr> + <tr><td><pre>emoji</pre></td></tr> + <tr><td><pre>3</pre></td></tr> + <tr><td><pre>2</pre></td></tr> + <tr><td><pre>vredestein</pre></td></tr> + <tr><td><pre>route</pre></td></tr> + <tr><td><pre>rapport</pre></td></tr> + <tr><td><pre>mal</pre></td></tr> + <tr><td><pre>excellent</pre></td></tr> + <tr><td><pre>dunlop</pre></td></tr> + <tr><td><pre>hiver</pre></td></tr> + <tr><td><pre>meilleur</pre></td></tr> + <tr><td><pre>bonne</pre></td></tr> + <tr><td><pre>sécurité</pre></td></tr> + <tr><td><pre>5</pre></td></tr> + <tr><td><pre>qualité</pre></td></tr> + </tbody> + </table> + <p> + Contrairement aux sélections de variables effectuées sur des + sous-ensembles des données + (table <h:ref href="#tbl-lizeo-feature-selection"/>), il est + plus clair que les premiers termes sélectionnés sont applicables + à tous les labels. En effet, dans les 30 premières variables, on + peut repérer les termes suivants : + </p> + <ul> + <li> + la combinaison de "<pre>très</pre>" et "<pre>pas</pre>" permet + d'indiquer une tonalité légèrement positive par défaut, et la + modifier en plus positif ou négatif, indépendamment du + label. La variable "<pre>très</pre>" n'est pas présente du + tout dans les 30 premières variables des sélections par + sous-ensemble, et seul <emph>MIFS</emph> sélectionne + "<pre>pas</pre>" (comme membre d'un + bi-gramme). <strong>RSMS</strong> par sous-ensembles + sélectionne cependant "<pre>non</pre>". Notons qu'il est très + important de conserver ces mots. Les tâches communes de + classification textuelle, comme la classification multi-labels + de documents, ne sont souvent pas affectées par la présence de + ces mots, qui sont alors considérés + comme <emph>stopword</emph> (mots-outil) et retirés du + texte. Dans notre cas, ils sont essentiels. + </li> + <li> + Nous avons relevé les termes d'appréciation généraux dans la + table <h:ref href="#tbl-lizeo-feature-selection-quali"/>. + </li> + </ul> + <table latex-align="llll"> + <caption id="tbl-lizeo-feature-selection-quali"> + Variables probablement utiles pour la tonalité de tous les + qualifieurs simultanément + </caption> + <thead> + <tr> + <th><strong>RSMS par époques</strong></th> + <th><emph>RSMS</emph></th> + <th><emph>MIFS</emph></th> + <th><emph>RFS</emph></th> + </tr> + </thead> + <tbody> + <tr> + <td><pre>très</pre></td> + <td><pre>malheureusement</pre></td> + <td><pre>assez\_bon</pre></td> + <td><pre>bluffé</pre></td> + </tr> + <tr> + <td><pre>pas</pre></td> + <td><pre>non</pre></td> + <td><pre>optimisées</pre></td> + <td><pre>regrette</pre></td> + </tr> + <tr> + <td><pre>content</pre></td> + <td></td> + <td><pre>justifie\_pas</pre></td> + <td><pre>négatif</pre></td> + </tr> + <tr> + <td><pre>bon</pre></td> + <td></td> + <td></td> + <td><pre>excellents</pre></td> + </tr> + <tr> + <td><pre>bien</pre></td> + <td></td> + <td></td> + <td><pre>catastrophique</pre></td> + </tr> + <tr> + <td><pre>meilleurs</pre></td> + <td></td> + <td></td> + <td><pre>pourri</pre></td> + </tr> + <tr> + <td><pre>plus</pre></td> + <td></td> + <td></td> + <td><pre>reproche</pre></td> + </tr> + <tr> + <td><pre>top</pre></td> + <td></td> + <td></td> + <td><pre>gain</pre></td> + </tr> + <tr> + <td><pre>satisfait</pre></td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td><pre>trop</pre></td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td><pre>mal</pre></td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td><pre>excellent</pre></td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td><pre>meilleur</pre></td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td><pre>bonne</pre></td> + <td></td> + <td></td> + <td></td> + </tr> + <tr> + <td><pre>qualité</pre></td> + <td></td> + <td></td> + <td></td> + </tr> + </tbody> + </table> + <figure> + <img src="images/featureselectionlizeofull.svg" /> + <figcaption id="fig-featureselectionlizeofull"> + Sélection de variables pour <strong>RSMS</strong> en comparant + l'optimisation par époques, et l'agrégation de l'optimisation + par sous-ensembles + </figcaption> + </figure> + <p> + La figure <h:ref href="#fig-featureselectionlizeofull"/> montre + que l'optimisation par époques obtient son meilleur résultat en + sélectionnant seulement 1% des variables (soit 5 fois moins que + l'agrégation de la sélection par sous-ensemble). Nous retenons + ces 200 meilleures variables. + </p> + <h3>Sélection de labels</h3> + <p> + En comparant les normes des colonnes de la + matrice <h:eq>B</h:eq>, on peut trouver les labels ayant une + plus forte norme, et donc ceux les mieux expliqués par les + variables sélectionnées. Grâce à cette information, on peut + identifier les labels difficiles. Nous constatons que les labels + fréquents ont plus tendance à être sélectionnés que les labels + moins fréquents. Pour les autres cas, nous présentons dans la + table <h:ref href="#tbl-unfrequent-selected-labels"/> la liste + des labels présents dans moins de 1% des documents, et dans la + table <h:ref href="#tbl-frequent-ignored-labels"/> la liste des + labels présents dans plus de 1% des documents. La + table <h:reft href="#bl-unfrequent-selected-labels"/> montre la + liste des qualifieurs relativement rares qui sont bien + représentés par le champ lexical sélectionné, tandis que la + table <h:ref href="#tbl-frequent-ignored-labels"/> montre que + certains labels fréquents sont ignorés pour la sélection de + variables. On note que l'image des produits est bien + retranscrite, ainsi que les caractéristiques techniques les plus + précises. + </p> + <table latex-align="rrl"> + <caption id="tbl-unfrequent-selected-labels"> + Rang de sélection des labels présents dans moins de 1% des + documents, parmi les 30 meilleurs labels + </caption> + <thead> + <tr> + <th>N<sup>o</sup></th> + <th>Rang</th> + <th>Description</th> + </tr> + </thead> + <tbody> + <tr> + <td>65</td> + <td>9</td> + <td>Characteristics / Labelling / Braking on wet surfaces</td> + </tr> + <tr> + <td>135</td> + <td>10</td> + <td>Attitude / Towards brands / Towards asian and budget brands</td> + </tr> + <tr> + <td>54</td> + <td>11</td> + <td>Characteristics / Image / Origin</td> + </tr> + <tr> + <td>136</td> + <td>13</td> + <td>Attitude / Towards brands / Towards premium brands</td> + </tr> + <tr> + <td>67</td> + <td>14</td> + <td>Characteristics / Labelling / Rolling resistance</td> + </tr> + <tr> + <td>202</td> + <td>15</td> + <td>Image/Reputation / Reputation/Quality</td> + </tr> + <tr> + <td>50</td> + <td>16</td> + <td>Performances / Sportiness</td> + </tr> + <tr> + <td>30</td> + <td>17</td> + <td>Performances / Safety / Grip</td> + </tr> + <tr> + <td>57</td> + <td>18</td> + <td>Characteristics / Image / Awareness</td> + </tr> + <tr> + <td>204</td> + <td>19</td> + <td>Global Satisfaction</td> + </tr> + <tr> + <td>16</td> + <td>20</td> + <td>Performances / Services / Michelin OnWay / Warranty</td> + </tr> + <tr> + <td>212</td> + <td>21</td> + <td>Performances / Safety / Road Holding / On wet road / Under extreme conditions</td> + </tr> + <tr> + <td>211</td> + <td>22</td> + <td>Performances / Safety / Road Holding / On dry road or not specified</td> + </tr> + <tr> + <td>214</td> + <td>23</td> + <td>Performances / Safety / Safety Generic) / On wet road / Under extreme conditions</td> + </tr> + <tr> + <td>220</td> + <td>24</td> + <td>Performances / Safety / Grip / On dry road or not specified</td> + </tr> + <tr> + <td>221</td> + <td>25</td> + <td>Performances / Safety / Grip / On wet road</td> + </tr> + <tr> + <td>213</td> + <td>26</td> + <td>Performances / Safety / Safety Generic) / On dry road or not specified</td> + </tr> + <tr> + <td>207</td> + <td>27</td> + <td>Performances / Performances Generic)</td> + </tr> + <tr> + <td>19</td> + <td>28</td> + <td>Performances / Services / Other / Warranty</td> + </tr> + <tr> + <td>203</td> + <td>29</td> + <td>Image/Reputation / Recommendation</td> + </tr> + <tr> + <td>222</td> + <td>30</td> + <td>Performances / Safety / Motivity / On dry road or not specified</td> + </tr> + </tbody> + </table> + <table latex-align="rrl"> + <caption id="tbl-frequent-ignored-labels"> + Rang de sélection des labels présents dans plus de 1% des + documents + </caption> + <thead> + <tr> + <th>N<sup>o</sup></th> + <th>Rang</th> + <th>Description</th> + </tr> + </thead> + <tbody> + <tr> + <td>52</td> + <td>1</td> + <td>Performances / Consumer feedback / Overall satisfaction</td> + </tr> + <tr> + <td>59</td> + <td>2</td> + <td>Characteristics / Image / Reputation</td> + </tr> + <tr> + <td>60</td> + <td>3</td> + <td>Characteristics / Image / Test results</td> + </tr> + <tr> + <td>21</td> + <td>4</td> + <td>Performances / Safety / Safety</td> + </tr> + <tr> + <td>61</td> + <td>5</td> + <td>Characteristics / Image / Intent to purchase</td> + </tr> + <tr> + <td>58</td> + <td>6</td> + <td>Performances / Consumer feedback / Recommendation</td> + </tr> + <tr> + <td>10</td> + <td>7</td> + <td>Characteristics / Price / Value for money</td> + </tr> + <tr> + <td>132</td> + <td>8</td> + <td>Attitude / Towards tyre type</td> + </tr> + <tr> + <td>133</td> + <td>12</td> + <td>Attitude / Towards tests</td> + </tr> + <tr> + <td>549</td> + <td>31</td> + <td>Performances / Safety / Traction</td> + </tr> + <tr> + <td>483</td> + <td>32</td> + <td>Performances / Wear life / Wear life</td> + </tr> + <tr> + <td>780</td> + <td>33</td> + <td>Performances / Safety / Wet traction</td> + </tr> + <tr> + <td>506</td> + <td>34</td> + <td>Performances / Ride performance / Noise</td> + </tr> + <tr> + <td>494</td> + <td>35</td> + <td>Performances / Safety / Handling</td> + </tr> + <tr> + <td>504</td> + <td>36</td> + <td>Performances / Ride performance / Ride experience</td> + </tr> + <tr> + <td>781</td> + <td>37</td> + <td>Performances / Safety / Dry traction</td> + </tr> + <tr> + <td>782</td> + <td>38</td> + <td>Performances / Safety / Snow/Winter traction</td> + </tr> + <tr> + <td>497</td> + <td>39</td> + <td>Performances / Safety / Stopping distance</td> + </tr> + <tr> + <td>505</td> + <td>40</td> + <td>Performances / Ride performance / Ride comfort</td> + </tr> + <tr> + <td>495</td> + <td>41</td> + <td>Performances / Safety / Steering</td> + </tr> + <tr> + <td>487</td> + <td>44</td> + <td>Performances / Toughness/Robustness / Toughness/Robustness</td> + </tr> + <tr> + <td>484</td> + <td>47</td> + <td>Performances / Wear life / Ageing</td> + </tr> + <tr> + <td>491</td> + <td>48</td> + <td>Performances / Environment / Environment</td> + </tr> + <tr> + <td>508</td> + <td>49</td> + <td>Characteristics / Image / Look/aesthetic</td> + </tr> + <tr> + <td>488</td> + <td>50</td> + <td>Performances / Wear life / Abnormal Wear</td> + </tr> + <tr> + <td>489</td> + <td>52</td> + <td>Characteristics / Price / Deal / Discount</td> + </tr> + <tr> + <td>558</td> + <td>53</td> + <td>Performances / Track/Sport performance / Track performance</td> + </tr> + <tr> + <td>784</td> + <td>58</td> + <td>Performances / Safety / Off road traction</td> + </tr> + </tbody> + </table> + <h2>Application : algorithme LSMR après sélection de variables et + de labels</h2> + <p> + Pour terminer, nous appliquons + l'algorithme <strong>LSMR</strong> avec bagging sur les deux + sous-ensembles de variables obtenus auparavant : les 993 + variables de la sélection de l'agrégation de l'algorithme + <strong>RSMS</strong>, et les 199 variables de la sélection + de <strong>RSMS</strong> par époques. Nous ajoutons également + les 993 et 199 meilleures variables selon <emph>RFS</emph> + et <emph>MIFS</emph>. Le résultat est présenté dans la table + <h:ref href="#tbl-lizeo-final"/>. Pour rappel, effectuer + l'apprentissage pour toutes les variables + avec <strong>LSMR</strong> donne une métrique aRMSE de 0.809. + </p> + <p> + Le processus général pour l'apprentissage est résumé dans la + figure <h:ref href="#fig-rsms-lsmr-apprentissage"/>. Une + première étape consiste à appliquer la sélection de variables + avec <strong>RSMS</strong>, en effectuant un découpage par + mini-batch. Une fois la liste des variables obtenues, + l'application de <strong>LSMR</strong> sur des sous-ensembles + tirés avec remise permet d'obtenir plusieurs modèles, chacun + étant évalué sur un ensemble de validation afin d'obtenir une + métrique. Nous obtenons également un ensemble hors du sac + (<emph>out of bag</emph>), non utilisé pour l'apprentissage ou + la validation, avec la sortie du modèle. La métrique obtenue par + validation permet de sélectionner les modèles les plus + pertinents. L'agrégation s'effectue ensuite en cherchant à + prédire pour chaque label indépendamment, sa valeur à partir des + valeurs prédites par les modèles de bootstrap. Afin de ne pas + réutiliser les individus ayant servi à l'apprentissage ou à la + validation, la valeur de ceux-ci est remplacée par la valeur de + prédiction moyenne. On obtient donc les variables à identifier, + des modèles de bootstrap, et un modèle de stacking. + </p> + <p> + Pour l'application du modèle sur un nouveau post, les étapes + sont décrites dans la figure + <h:ref href="#fig-rsms-lsmr-inference"/>. Les mots du texte + correspondants aux variables sélectionnés sont reconnus, puis + chaque modèle de bootstrap effectue une prédiction, et enfin le + modèle de stacking permet d'obtenir une valeur pour tous les + labels. + </p> + <table latex-align="rrrrr"> + <caption id="tbl-lizeo-final"> + Évaluation avec <strong>LSMR</strong> + bagging (aRMSE) des + deux ensembles de variables retenus : agrégation + de <strong>RSMS</strong> sur des sous-ensembles, et + optimisation de <strong>RSMS</strong> sur le jeu de données + complet par époques + </caption> + <thead> + <tr> + <td><strong>Pourcentage de variables</strong></td> + <td><strong>RSMS</strong> par époques</td> + <td><strong>RSMS</strong> agrégé</td> + <td><emph>RFS</emph></td> + <td><emph>MIFS</emph></td> + </tr> + </thead> + <tbody> + <tr> + <td>5% (993 variables)</td> + <td>0.810</td> + <td><strong>0.807</strong></td> + <td>0.815</td> + <td>0.819</td> + </tr> + <tr> + <td>1% (199 variables)</td> + <td><strong>0.810</strong></td> + <td>0.812</td> + <td>0.817</td> + <td>0.820</td> + </tr> + </tbody> + </table> + <figure> + <img src="images/lsmrrsmsapprentissage.svg" /> + <figcaption id="fig-rsms-lsmr-apprentissage"> + Schéma de synthèse de l'application de <strong>RSMS</strong> + et <strong>LSMR</strong> sur le jeu de données total + </figcaption> + </figure> + <figure> + <img src="images/lsmrrsmsinference.svg" /> + <figcaption id="fig-rsms-lsmr-inference"> + Schéma de synthèse de l'application de <strong>RSMS</strong> + et <strong>LSMR</strong> sur le jeu de données total : + application sur un nouveau post non labellisé + </figcaption> + </figure> + <h2>Conclusion</h2> + <p> + Nous avons évalué notre algorithme de sélection de variables + multi-labels, <strong>RSMS</strong>, sur un jeu de données + textuel réel, en appliquant notre approche de régression + multi-labels <strong>LSMR</strong> pour le valider. Selon notre + mode d'application de <strong>RSMS</strong>, par époques ou en + agrégeant les rangs des variables sélectionnées sur des + sous-ensembles, nous obtenons respectivement une meilleure + sélection de variables qualitativement, et une sélection plus + adaptée au problème, en comparaison avec les + algorithmes <emph>RFS</emph> et <emph>MIFS</emph>. Dans le + premier cas, cette évaluation a montré l'utilité de la sélection + de variables pour la réduction de dimension. Dans le second cas, + elle a montré que la sélection de variables permet d'obtenir une + plus faible erreur de régression. + </p> + <h1>Conclusion et perspectives</h1> + <h2>Bilan des travaux effectués</h2> + <p> + Dans cette thèse, nous avons présenté un état de l'art de + l'apprentissage semi-supervisé et multi-labels pour la + régression, en insistant également sur la sélection de + variables. Ceci nous a amené à proposer un algorithme de + régression semi-supervisé, <emph>LapS3L</emph>. + </p> + <p> + Cet algorithme utilise les données non labellisées de deux + façons : + </p> + <ul> + <li> + une première étape d'extraction de variables non supervisée + permet d'obtenir de nouvelles variables permettant d'exprimer + une relation linéaire entre les variables et la variable + cible. Cette étape est tirée de + l'algorithme <emph>SSSL</emph>. + </li> + <li> + une seconde étape qui utilise une régularisation Laplacienne, + semi-supervisée, permettant de relier les variables réelles et + les variables extraites. + </li> + </ul> + <p> + <emph>LapS3L</emph> obtient de bons résultats de généralisation + pour la régression, sur des jeux de données publics, et sur un + jeu de données spécifique. + </p> + <p> + Afin d'adapter <emph>LapS3L</emph> aux problèmes de régression + multi-labels, nous avons modifié la régularisation de la seconde + partie en ajoutant un terme multi-labels : concrètement, si deux + labels obtiennent des valeurs similaires sur les mêmes + individus, alors on peut les considérer comme similaires. À + partir de ces similarités entre labels, il est possible + d'utiliser pour la régularisation l'hypothèse suivante : si deux + labels sont similaires, alors les modèles servant à effectuer + leur prédiction doivent être similaires. + </p> + <p> + Nous avons montré que l'algorithme résultant, <emph>LSMR</emph>, + est compétitif avec l'état de l'art de la régression + multi-labels, tout en donnant de meilleures performances que la + régularisation multi-labels seule. + </p> + <p> + Pour faciliter l'apprentissage, nous nous sommes aussi penchés + sur la sélection de variables semi-supervisée et + multi-labels. Étant donné le nombre important de labels que nous + serions amenés à traiter, nous avons proposé un compromis entre + la sélection de variables mono-label et multi-labels en guidant + la sélection de variables par la sélection de + labels. Concrètement, nous avons conçu notre algorithme pour + résoudre simultanément le problème de sélection de variables, et + la sélection de labels, afin que les variables retenues ne + puissent pas être influencées par les labels dont la + modélisation est trop difficile ou impossible. + </p> + <p> + Enfin, nous avons appliqué <strong>LSMR</strong> + et <strong>RSMS</strong> sur un jeu de données réel, de + l'entreprise Lizeo, ayant de nombreuses particularités qui nous + ont amené à adapter légèrement nos travaux. La version retenue + de <strong>LSMR</strong> utilise la technique de <emph>Bootstrap + Aggregating</emph>, ou <emph>Bagging</emph>, qui vise à + ré-échantillonner (avec remise) le jeu de données pour apprendre + un modèle par échantillon, puis une aggrégation des prédictions + par un modèle de <emph>stacking</emph>. Ce modèle final nous + permet d'ignorer les valeurs non pertinentes, une spécificité du + jeu de données. Contrairement à <emph>MIFS</emph> + et <emph>RFS</emph>, les variables sélectionnées + par <emph>RSMS</emph> permettent soit d'obtenir une erreur de + régression plus faible de <emph>LSMR</emph>, soit d'obtenir un + modèle très simple. + </p> + <h2>Perspectives d'amélioration</h2> + <p> + Les pistes d'amélioration sont nombreuses pour nos travaux. + </p> + <p> + En ce qui concerne <strong>LSMR</strong>, nous pourrions tenter + d'utiliser d'autres régularisations multi-labels. En effet, + indépendamment de la performance de <strong>LSMR</strong>, les + résultats obtenus par la régularisation Laplacienne multi-labels + semblent montrer les limites de cette approche, en comparant + avec la régularisation <emph>CMTL</emph>. Cette dernière est + similaire, à ceci près que l'a-priori sur la structure des + labels est inféré à partir des données. Nous pourrions également + envisager d'intégrer la sélection de labels dans la méthode + d'apprentissage <strong>LSMR</strong>, de façon à ne pas + contraindre le modèle sur les labels qu'il ne pourra de toutes + façons pas représenter fidèlement. + </p> + <p> + Nous pourrions aussi tenter de modifier les a-priori dont nous + disposons sur les labels grâce aux connaissances métier. En + effet, les labels forment une hiérarchie : certains sont plus + génériques et recouvrent des sous-labels plus spécifiques. Par + exemple, si le terme "savonnette" est tantôt employé pour la + tenue sur route humide ou sur route enneigée, cela traduit une + proximité naturelle entre ces deux labels. Cette proximité + pourrait être retrouvée en inspectant simplement la hiérarchie + des <emph>qualifiers</emph>. + </p> + <p> + Pour <emph>RSMS</emph>, nous pourrions envisager d'utiliser une + régularisation non convexe, telle que la régularisation + <h:eq>\ell_{2, 1 - 2}</h:eq>. + </p> + <p> + En ce qui concerne l'application, il reste à harmoniser la + classification et la régression. En effet, le score prédit pour + chaque label n'est pas toujours intéressant ; il ne l'est que si + le <emph>qualifier</emph> est bien mentionné dans le texte. Bien + que l'agrégation par <emph>stacking</emph> permette d'ignorer le + score prédit pour les qualifier non présents, les modèles + bootstrap cherchent à obtenir la valeur 0 si le qualifier n'est + pas présent. Cette idée devrait donc être au cœur de + l'optimisation d'un algorithme unifiant la classification et la + régression. + </p> + <h:appendix/> + <h1>Publications personnelles</h1> + <h2>Revues internationales</h2> + <ul> + <li> + Seif-Eddine Benkabou, + Khalid Benabdeslem, + <strong>Vivien Kraus</strong>, + Kilian Bourhis, + Bruno Canitia, + <emph>Local Anomaly Detection for Multivariate Time Series by + Temporal Dependency Based on Poisson Model</emph>, in + revision, + <emph>IEEE Transactions on Neural Networks and Learning + Systems</emph> + </li> + </ul> + <h2>Conférences internationales</h2> + <ul> + <li> + <strong>Vivien Kraus</strong>, + Khalid Benabdeslem, + Bruno Canitia, + <emph>Laplacian-based Semi-supervised Multi-Label + Regression.</emph>, in + <emph>International Joint Conference on Neural Networks + (IJCNN).</emph> + IEEE, 2020. + </li> + <li> + <strong>Vivien Kraus</strong>, + Seif-Eddine Benkabou, + Khalid Benabdeslem, + Frédéric Cherqui, + <emph>An improved Laplacian semi-supervised regression</emph>, in + <emph>IEEE 30th International Conference on Tools with + Artificial Intelligence (ICTAI).</emph> + + IEEE, 2018. p 564-570. + </li> + </ul> + <h2>Conférences nationales</h2> + <ul> + <li> + Seif-Eddine Benkabou, + Khalid Benabdeslem, + <strong>Vivien Kraus</strong>, + Kilian Bourhis + and Bruno Canitia. + + <emph>Détection contextuelle d'anomalies à partir de séries + temporelles multi-variées à base de modèle de + Poisson</emph>, + + in + + <emph>Conférence sur l'Apprentissage automatique (CAp + 2019)</emph>. + </li> + <li> + <strong>Vivien Kraus</strong>, + Khalid Benabdeslem, + Frédéric Cherqui, + + <emph>Régression Laplacienne semi-supervisée pour la + reconstitution des dates de pose des réseaux + d'assainissement</emph>, + + <emph>Extraction et Gestion des Connaissances (EGC18)</emph> + + EGC 2018. + </li> + </ul> + <h2>Travaux en cours</h2> + <ul> + <li> + <strong>Vivien Kraus</strong>, + Khalid Benabdeslem, + Bruno Canitia. + + <emph>RSMS: Robust Semi-supervised Multi-label feature + Selection for regression.</emph> + + Preprint, 2021. + </li> + </ul> + + <!-- ____________________________________________ + −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− + Fin du manuscrit, début de la bibliographie. + −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− --> + + <h:bibliography style="unsrt"> + <b:inproceedings id="ji_simple_2012"> + <b:title> + A simple algorithm for semi-supervised learning with + improved generalization error bound + </b:title> + <b:author> + Ji, Ming and Yang, Tianbao and Lin, Binbin and Jin, Rong and + Han, Jiawei + </b:author> + <b:booktitle> + Proceedings of the 29th International Coference on + International Conference on Machine Learning + </b:booktitle> + <b:pages>835--842</b:pages> + <b:year>2012</b:year> + </b:inproceedings> + <b:article id="belkin_manifold_2006"> + <b:title> + Manifold regularization: A geometric framework for learning + from labeled and unlabeled examples + </b:title> + <b:author> + Belkin, Mikhail and Niyogi, Partha and Sindhwani, Vikas + </b:author> + <b:journal>Journal of machine learning research</b:journal> + <b:volume>7</b:volume> + <b:number>Nov</b:number> + <b:pages>2399-2434</b:pages> + <b:year>2006</b:year> + </b:article> + <b:book id="chapelle_semi-supervised_2006"> + <b:title>Semi-Supervised Learning</b:title> + <b:isbn>978-0-262-03358-9</b:isbn> + <b:url>http://mitpress.universitypressscholarship.com/view/10.7551/mitpress/9780262033589.001.0001/upso-9780262033589</b:url> + <b:urldate>2017-10-05</b:urldate> + <b:publisher>The MIT Press</b:publisher> + <b:editor>Chapelle, Olivier and Scholkopf, Bernhard and Zien, Alexander</b:editor> + <b:month>sep</b:month> + <b:year>2006</b:year> + <b:doi>10.7551/mitpress/9780262033589.001.0001</b:doi> + </b:book> + <b:inproceedings id="zhu_semi-supervised_nodate"> + <b:title> + Semi-Supervised Learning Using Gaussian Fields and Harmonic + Functions + </b:title> + <b:author> + Zhu, Xiaojin and Ghahramani, Zoubin and Lafferty, John D + </b:author> + <b:booktitle> + Proceedings of the 20th International conference on Machine + learning (ICML-03) + </b:booktitle> + <b:pages>912-919</b:pages> + <b:year>2003</b:year> + </b:inproceedings> + <b:article id="doquire_graph_2013"> + <b:title> + A graph Laplacian based approach to semi-supervised feature + selection for regression problems + </b:title> + <b:volume>121</b:volume> + <b:issn>09252312</b:issn> + <b:url>http://linkinghub.elsevier.com/retrieve/pii/S0925231213001537</b:url> + <b:doi>10.1016/j.neucom.2012.10.028</b:doi> + <b:language>en</b:language> + <b:urldate>2017-10-06</b:urldate> + <b:journal>Neurocomputing</b:journal> + <b:author>Doquire, Gauthier and Verleysen, Michel</b:author> + <b:month>dec</b:month> + <b:year>2013</b:year> + <b:pages>5--13</b:pages> + </b:article> + <b:article id="alalga_soft-constrained_2016"> + <b:title> + Soft-constrained Laplacian score for semi-supervised + multi-label feature selection + </b:title> + <b:volume>47</b:volume> + <b:issn>0219-1377, 0219-3116</b:issn> + <b:url>http://link.springer.com/10.1007/s10115-015-0841-8</b:url> + <b:doi>10.1007/s10115-015-0841-8</b:doi> + <b:language>en</b:language> + <b:number>1</b:number> + <b:urldate>2017-10-03</b:urldate> + <b:journal>Knowledge and Information Systems</b:journal> + <b:author> + Alalga, Abdelouahid and Benabdeslem, Khalid and Taleb, Nora + </b:author> + <b:month>apr</b:month> + <b:year>2016</b:year> + <b:pages>75-98</b:pages> + </b:article> + <b:inproceedings id="sousa_kernelized_nodate"> + <b:title> + Kernelized Constrained Gaussian Fields and Harmonic + Functions for Semi-supervised Learning + </b:title> + <b:abstract> + Graph-based semi-supervised learning (SSL) methods are + effective on many application domains. Despite such an + effectiveness, many of these methods are transductive in + nature, being uncapable to provide generalization for the + entire sample space. In this paper, we generalize three + existing graph-based transductive methods through kernel + expansions on reproducing kernel Hilbert spaces. In + addition, our methods can easily generate an inductive model + in a parameter-free way, given a graph Laplacian constructed + from both labeled and unlabeled examples and a label + matrix. Through experiments on benchmark data sets, we show + that the proposed methods are effective on inductive SSL + tasks in comparison to manifold regularization methods. + </b:abstract> + <b:language>en</b:language> + <b:author>Sousa, Celso A R</b:author> + <b:booktitle> + 2020 International Joint Conference on Neural Networks + (IJCNN) + </b:booktitle> + <b:pages>1--8</b:pages> + <b:year>2020</b:year> + <b:organization>IEEE</b:organization> + </b:inproceedings> + <b:inproceedings id="liu_semi-supervised_2006"> + <b:title> + Semi-supervised multi-label learning by constrained + non-negative matrix factorization + </b:title> + <b:volume>6</b:volume> + <b:url>https://vvvvw.aaai.org/Papers/AAAI/2006/AAAI06-067.pdf</b:url> + <b:urldate>2017-10-09</b:urldate> + <b:booktitle> + Proceedings of the 21st national conference on Artificial + intelligence-Volume 1 + </b:booktitle> + <b:author>Liu, Yi and Jin, Rong and Yang, Liu</b:author> + <b:year>2006</b:year> + <b:pages>421-426</b:pages> + </b:inproceedings> + <b:incollection id="gunopulos_constrained_2011"> + <b:address>Berlin, Heidelberg</b:address> + <b:title> + Constrained Laplacian Score for Semi-supervised Feature + Selection + </b:title> + <b:volume>6911</b:volume> + <b:isbn>978-3-642-23779-9 978-3-642-23780-5</b:isbn> + <b:url>http://link.springer.com/10.1007/978-3-642-23780-5_23</b:url> + <b:urldate>2017-10-05</b:urldate> + <b:booktitle> + Machine Learning and Knowledge Discovery in Databases + </b:booktitle> + <b:publisher>Springer Berlin Heidelberg</b:publisher> + <b:author>Benabdeslem, Khalid and Hindawi, Mohammed</b:author> + <b:editor> + Gunopulos, Dimitrios and Hofmann, Thomas and Malerba, Donato + and Vazirgiannis, Michalis + </b:editor> + <b:year>2011</b:year> + <b:doi>10.1007/978-3-642-23780-5_23</b:doi> + <b:pages>204--218</b:pages> + </b:incollection> + <b:article id="zhang_semi-supervised_2009"> + <b:title>Semi-Supervised Multi-Task Regression</b:title> + <b:author>Zhang, Yu and Yeung, Dit-Yan</b:author> + <b:journal> + Machine Learning and Knowledge Discovery in Databases + </b:journal> + <b:pages>617--631</b:pages> + <b:year>2009</b:year> + <b:publisher>Springer</b:publisher> + <b:abstract> + Labeled data are needed for many machine learning + applications but the amount available in some applications + is scarce. Semi-supervised learning and multi-task learning + are two of the approaches that have been proposed to + alleviate this problem. In this paper, we seek to integrate + these two approaches for regression applications. We first + propose a new supervised multi-task regression method called + SMTR, which is based on Gaussian processes (GP) with the + assumption that the kernel parameters for all tasks share a + common prior. We then incorporate unlabeled data into SMTR + by changing the kernel function of the GP prior to a + data-dependent kernel function, resulting in a + semi-supervised extension of SMTR, called SSMTR. Moreover, + we incorporate pairwise information into SSMTR to further + boost the learning performance for applications in which + such information is available. Experiments conducted on two + commonly used data sets for multi-task regression + demonstrate the effectiveness of our methods. + </b:abstract> + </b:article> + <b:inproceedings id="mifs"> + <b:title>Multi-Label Informed Feature Selection.</b:title> + <b:booktitle> + Proceedings of the Twenty-Fifth International Joint + Conference on Artificial Intelligence + </b:booktitle> + <b:author> + Jian, Ling and Li, Jundong and Shu, Kai and Liu, Huan + </b:author> + <b:year>2016</b:year> + <b:pages>1627--1633</b:pages> + </b:inproceedings> + <b:inproceedings id="drucker1997support"> + <b:title>Support vector regression machines</b:title> + <b:author> + Drucker, Harris and Burges, Christopher JC and Kaufman, + Linda and Smola, Alex J and Vapnik, Vladimir + </b:author> + <b:booktitle> + Advances in neural information processing systems + </b:booktitle> + <b:pages>155--161</b:pages> + <b:year>1997</b:year> + </b:inproceedings> + <b:article id="chapelle_optimization_2008"> + <b:title>Optimization Techniques for Semi-Supervised Support Vector Machines</b:title> + <b:volume>9</b:volume> + <b:issn>1532-4435</b:issn> + <b:url>http://dl.acm.org/citation.cfm?id=1390681.1390688</b:url> + <b:journal>Journal of machine learning research</b:journal> + <b:author>Chapelle, Olivier and Sindhwani, Vikas and Keerthi, Sathiya S.</b:author> + <b:month>jun</b:month> + <b:year>2008</b:year> + <b:pages>203--233</b:pages> + </b:article> + <b:inproceedings id="bennett1999semi"> + <b:title>Semi-supervised support vector machines</b:title> + <b:author>Bennett, Kristin P and Demiriz, Ayhan</b:author> + <b:booktitle>Advances in Neural Information processing systems</b:booktitle> + <b:pages>368--374</b:pages> + <b:year>1999</b:year> + </b:inproceedings> + <b:article id="chen2012laplacian"> + <b:title> + Laplacian embedded regression for scalable manifold + regularization + </b:title> + <b:author>Chen, Lin and Tsang, Ivor W and Xu, Dong</b:author> + <b:journal> + IEEE transactions on neural networks and learning systems + </b:journal> + <b:volume>23</b:volume> + <b:number>6</b:number> + <b:pages>902--915</b:pages> + <b:year>2012</b:year> + <b:publisher>IEEE</b:publisher> + </b:article> + <b:article id="selftraining"> + <b:author>H. Scudder</b:author> + <b:journal> + IEEE Transactions on Information Theory, + </b:journal> + <b:title> + Probability of error of some adaptive pattern-recognition + machines, + </b:title> + <b:year>1965</b:year> + <b:volume>11</b:volume> + <b:number>3</b:number> + <b:pages>363-371</b:pages> + <b:doi>10.1109/TIT.1965.1053799</b:doi> + </b:article> + <b:article id="cramer2002origins"> + <b:title>The origins of logistic regression</b:title> + <b:author>Cramer, JS</b:author> + <b:journal>Tinbergen Institute Working Paper</b:journal> + <b:volume>2002</b:volume> + <b:number>119/4</b:number> + <b:year>2002</b:year> + </b:article> + <b:inproceedings id="levatic_semi-supervised_2014"> + <b:title>Semi-supervised learning for multi-target regression</b:title> + <b:url>http://link.springer.com/chapter/10.1007/978-3-319-17876-9_1</b:url> + <b:urldate>2017-10-11</b:urldate> + <b:booktitle>International Workshop on New Frontiers in Mining Complex Patterns</b:booktitle> + <b:publisher>Springer</b:publisher> + <b:author>Levatić, Jurica and Ceci, Michelangelo and Kocev, Dragi and Džeroski, Sašo</b:author> + <b:year>2014</b:year> + <b:pages>3--18</b:pages> + </b:inproceedings> + <b:inproceedings id="arazo_pseudo-labeling_nodate"> + <b:title> + Pseudo-labeling and confirmation bias in deep + semi-supervised learning + </b:title> + <b:author> + Arazo, Eric and Ortego, Diego and Albert, Paul and O’Connor, + Noel E and McGuinness, Kevin + </b:author> + <b:booktitle> + 2020 International Joint Conference on Neural Networks + (IJCNN) + </b:booktitle> + <b:pages>1--8</b:pages> + <b:year>2020</b:year> + <b:organization>IEEE</b:organization> + <b:abstract> + Semi-supervised learning, i.e. jointly learning from labeled + and unlabeled samples, is an active research topic due to + its key role on relaxing human supervision. In the context + of image classification, recent advances to learn from + unlabeled samples are mainly focused on consistency + regularization methods that encourage invariant predictions + for different perturbations of unlabeled samples. We, + conversely, propose to learn from unlabeled data by + generating soft pseudo-labels using the network + predictions. We show that a naive pseudo-labeling overfits + to incorrect pseudo-labels due to the so-called confirmation + bias and demonstrate that mixup augmentation and setting a + minimum number of labeled samples per mini-batch are + effective regularization techniques for reducing it. The + proposed approach achieves state-of-the-art results in + CIFAR-10/100, SVHN, and Mini-ImageNet despite being much + simpler than other methods. These results demonstrate that + pseudo-labeling alone can outperform consistency + regularization methods, while the opposite was supposed in + previous work. Source code is available at + https://git.io/fjQsC. + </b:abstract> + <b:language>en</b:language> + </b:inproceedings> + <b:inproceedings id="bennett_semi-supervised_1998"> + <b:address>Cambridge, MA, USA</b:address> + <b:series>NIPS'98</b:series> + <b:title>Semi-supervised Support Vector Machines</b:title> + <b:url>http://dl.acm.org/citation.cfm?id>3009055.3009107</b:url> + <b:booktitle> + Proceedings of the 11th International Conference on Neural + Information Processing Systems + </b:booktitle> + <b:publisher>MIT Press</b:publisher> + <b:author>Bennett, Kristin P. and Demiriz, Ayhan</b:author> + <b:year>1998</b:year> + <b:pages>368--374</b:pages> + </b:inproceedings> + <b:article id="levatic_self_training_2017"> + <b:title> + Self-training for multi-target regression with tree + ensembles + </b:title> + <b:volume>123</b:volume> + <b:issn>09507051</b:issn> + <b:url>https://linkinghub.elsevier.com/retrieve/pii/S0950705117300813</b:url> + <b:doi>10.1016/j.knosys.2017.02.014</b:doi> + <!-- <b:abstract> --> + <!-- Semi-supervised learning (SSL) aims to use unlabeled data as --> + <!-- an additional source of information in order to improve upon --> + <!-- the performance of supervised learning methods. The --> + <!-- availability of labeled data is often limited due to the --> + <!-- expensive and/or tedious annotation process, while unlabeled --> + <!-- data could be easily available in large amounts. This is --> + <!-- particularly true for predictive modelling problems with a --> + <!-- structured output space. In this study, we address the task --> + <!-- of SSL for multi-target regression (MTR), where the output --> + <!-- space consists of multiple numerical values. We extend the --> + <!-- self-training approach to perform SSL for MTR by using a --> + <!-- random forest of predictive clustering trees. In --> + <!-- self-training, a model iteratively uses its own most --> + <!-- reliable predictions, hence a good measure for the --> + <!-- reliability of predictions is essential. Given that --> + <!-- reliability estimates for MTR predictions have not yet been --> + <!-- studied, we propose four such estimates, based on mechanisms --> + <!-- provided within ensemble learning. In addition to these four --> + <!-- scores, we use two benchmark scores (oracle and random) to --> + <!-- empirically determine the performance limits of --> + <!-- selftraining. We also propose an approach to automatically --> + <!-- select a threshold for the identification of the most --> + <!-- reliable predictions to be used in the next iteration. An --> + <!-- empirical evaluation on a large collection of datasets for --> + <!-- MTR shows that self-training with any of the proposed --> + <!-- reliability scores is able to consistently improve over --> + <!-- supervised random forests and multi-output support vector --> + <!-- regression. This is also true when the reliability threshold --> + <!-- is selected automatically. --> + <!-- </b:abstract> --> + <b:language>en</b:language> + <b:urldate>2020-09-09</b:urldate> + <b:journal>Knowledge-Based Systems</b:journal> + <b:author> + Levatić, Jurica and Ceci, Michelangelo and Kocev, Dragi and + Džeroski, Sašo + </b:author> + <b:month>may</b:month> + <b:year>2017</b:year> + <b:pages>41--60</b:pages> + </b:article> + <b:inproceedings id="blum_combining_1998"> + <b:address>New York, NY, USA</b:address> + <b:series>COLT' 98</b:series> + <b:title> + Combining Labeled and Unlabeled Data with Co-training + </b:title> + <b:isbn>1-58113-057-0</b:isbn> + <b:url>http://doi.acm.org/10.1145/279943.279962</b:url> + <b:doi>10.1145/279943.279962</b:doi> + <b:booktitle> + Proceedings of the Eleventh Annual Conference on + Computational Learning Theory + </b:booktitle> + <b:publisher>ACM</b:publisher> + <b:author>Blum, Avrim and Mitchell, Tom</b:author> + <b:year>1998</b:year> + <b:pages>92--100</b:pages> + </b:inproceedings> + <b:inproceedings id="zhou_semi-supervised_2005"> + <b:title> + Semi-Supervised Regression with Co-Training. + </b:title> + <b:volume>5</b:volume> + <b:url>http://cs.nju.edu.cn/_upload/tpl/00/c5/197/template197/publications/ijcai05.pdf</b:url> + <b:urldate>2017-10-12</b:urldate> + <b:booktitle> + Proceedings of the 19th international joint conference on + Artificial intelligence + </b:booktitle> + <b:author>Zhou, Zhi-Hua and Li, Ming</b:author> + <b:year>2005</b:year> + <b:pages>908--913</b:pages> + </b:inproceedings> + <b:inproceedings id="barkia_semi-supervised_2011"> + <b:title> + Semi-supervised Feature Importance Evaluation with Ensemble + Learning + </b:title> + <b:isbn>978-1-4577-2075-8 978-0-7695-4408-3</b:isbn> + <b:url>http://ieeexplore.ieee.org/document/6137207/</b:url> + <b:doi>10.1109/ICDM.2011.129</b:doi> + <b:urldate>2017-10-03</b:urldate> + <b:publisher>IEEE</b:publisher> + <b:booktitle> + 2011 IEEE 11th International Conference on Data Mining + </b:booktitle> + <b:pages>31--40</b:pages> + <b:month>dec</b:month> + <b:year>2011</b:year> + <b:organization>IEEE</b:organization> + <b:author> + Barkia, Hasna and Elghazel, Haytham and Aussem, Alex + </b:author> + </b:inproceedings> + <b:inproceedings id="zhao_semi-supervised_2007"> + <b:title> + Semi-supervised feature selection via spectral analysis + </b:title> + <b:url>http://epubs.siam.org/doi/abs/10.1137/1.9781611972771.75</b:url> + <b:urldate>2017-10-09</b:urldate> + <b:booktitle> + Proceedings of the 2007 SIAM International Conference on + Data Mining + </b:booktitle> + <b:publisher>SIAM</b:publisher> + <b:author>Zhao, Zheng and Liu, Huan</b:author> + <b:year>2007</b:year> + <b:pages>641--646</b:pages> + </b:inproceedings> + <b:article id="benabdeslem_efficient_2014"> + <b:title> + Efficient Semi-Supervised Feature Selection: Constraint, + Relevance, and Redundancy + </b:title> + <b:volume>26</b:volume> + <b:issn>1041-4347</b:issn> + <b:shorttitle> + Efficient Semi-Supervised Feature Selection + </b:shorttitle> + <b:url>http://ieeexplore.ieee.org/document/6520860/</b:url> + <b:doi>10.1109/TKDE.2013.86</b:doi> + <b:number>5</b:number> + <b:urldate>2017-10-05</b:urldate> + <b:journal> + IEEE Transactions on Knowledge and Data Engineering + </b:journal> + <b:author>Benabdeslem, Khalid and Hindawi, Mohammed</b:author> + <b:month>may</b:month> + <b:year>2014</b:year> + <b:pages>1131--1143</b:pages> + </b:article> + <b:inproceedings id="hindawi_local--global_2013"> + <b:address>New York, NY, USA</b:address> + <b:series>CIKM '13</b:series> + <b:title> + Local-to-global semi-supervised feature selection + </b:title> + <b:isbn>978-1-4503-2263-8</b:isbn> + <b:url>http://doi.acm.org/10.1145/2505515.2505542</b:url> + <b:doi>10.1145/2505515.2505542</b:doi> + <b:abstract> + Variable-weighting approaches are well-known in the context + of embedded feature selection. Generally, this task is + performed in a global way, when the algorithm selects a + single cluster-independent subset of features (global + feature selection). However, there exist other approaches + that aim to select cluster-specific subsets of features + (local feature selection). Global and local feature + selection have different objectives, nevertheless, in this + paper we propose a novel embedded approach which locally + weights the variables towards a global feature + selection. The proposed approach is presented in the + semi-supervised paradigm. Experiments on some known data + sets are presented to validate our model and compare it with + some representative methods. + </b:abstract> + <b:urldate>2017-10-09</b:urldate> + <b:booktitle> + Proceedings of the 22nd ACM international conference on + Conference on information & knowledge management + </b:booktitle> + <b:publisher>ACM</b:publisher> + <b:author>Hindawi, Mohammed and Benabdeslem, Khalid</b:author> + <b:year>2013</b:year> + <b:keywords> + semi-supervised learning, constraints, feature selection, + variable weighting + </b:keywords> + <b:pages>2159--2168</b:pages> + </b:inproceedings> + <b:inproceedings id="collobert2008unified"> + <b:title> + A unified architecture for natural language processing: Deep + neural networks with multitask learning + </b:title> + <b:author>Collobert, Ronan and Weston, Jason</b:author> + <b:booktitle> + Proceedings of the 25th international conference on Machine + learning + </b:booktitle> + <b:pages>160--167</b:pages> + <b:year>2008</b:year> + </b:inproceedings> + <b:inproceedings id="argyriou2008spectral"> + <b:title> + A spectral regularization framework for multi-task structure + learning + </b:title> + <b:author> + Argyriou, Andreas and Pontil, Massimiliano and Ying, Yiming + and Micchelli, Charles A + </b:author> + <b:booktitle> + Advances in neural information processing systems + </b:booktitle> + <b:pages>25--32</b:pages> + <b:year>2008</b:year> + </b:inproceedings> + <b:inproceedings id="sarcos"> + <b:title> + Locally weighted projection regression: + An <h:eq>\mathcal{O}(n)</h:eq> algorithm for incremental + real time learning in high dimensional spaces + </b:title> + <b:author>Vijayakumar, S. and Schaal, S.</b:author> + <b:booktitle> + Proceedings of the Seventeenth International Conference on + Machine Learning (ICML 2000) + </b:booktitle> + <b:volume>1</b:volume> + <b:pages>288-293</b:pages> + <b:address>Stanford, CA</b:address> + <b:year>2000</b:year> + <b:note>clmc</b:note> + <b:url>http://www-clmc.usc.edu/publications/V/vijayakumar-ICML2000.pdf</b:url> + </b:inproceedings> + <b:article id="spyromitros_xioufis_multi_target_2016"> + <b:title> + Multi-Target Regression via Input Space Expansion: Treating + Targets as Inputs + </b:title> + <b:volume>104</b:volume> + <b:issn>0885-6125, 1573-0565</b:issn> + <b:shorttitle> + Multi-Target Regression via Input Space Expansion + </b:shorttitle> + <b:url>http://arxiv.org/abs/1211.6581</b:url> + <b:doi>10.1007/s10994-016-5546-z</b:doi> + <!-- <b:abstract> --> + <!-- In many practical applications of supervised learning the --> + <!-- task involves the prediction of multiple target variables --> + <!-- from a common set of input variables. When the prediction --> + <!-- targets are binary the task is called multi-label --> + <!-- classification, while when the targets are continuous the --> + <!-- task is called multi-target regression. In both tasks, --> + <!-- target variables often exhibit statistical dependencies and --> + <!-- exploiting them in order to improve predictive accuracy is a --> + <!-- core challenge. A family of multi-label classification --> + <!-- methods address this challenge by building a separate model --> + <!-- for each target on an expanded input space where other --> + <!-- targets are treated as additional input variables. Despite --> + <!-- the success of these methods in the multi-label --> + <!-- classification domain, their applicability and effectiveness --> + <!-- in multi-target regression has not been studied until --> + <!-- now. In this paper, we introduce two new methods for --> + <!-- multi-target regression, called Stacked Single-Target and --> + <!-- Ensemble of Regressor Chains, by adapting two popular --> + <!-- multi-label classification methods of this --> + <!-- family. Furthermore, we highlight an inherent problem of --> + <!-- these methods - a discrepancy of the values of the --> + <!-- additional input variables between training and prediction - --> + <!-- and develop extensions that use out-of-sample estimates of --> + <!-- the target variables during training in order to tackle this --> + <!-- problem. The results of an extensive experimental evaluation --> + <!-- carried out on a large and diverse collection of datasets --> + <!-- show that, when the discrepancy is appropriately mitigated, --> + <!-- the proposed methods attain consistent improvements over the --> + <!-- independent regressions baseline. Moreover, two versions of --> + <!-- Ensemble of Regression Chains perform significantly better --> + <!-- than four state-of-the-art methods including --> + <!-- regularization-based multi-task learning methods and a --> + <!-- multi-objective random forest approach. --> + <!-- </b:abstract> --> + <b:number>1</b:number> + <b:urldate>2017-10-16</b:urldate> + <b:journal>Machine Learning</b:journal> + <b:author> + Spyromitros-Xioufis, Eleftherios and Tsoumakas, Grigorios + and Groves, William and Vlahavas, Ioannis + </b:author> + <b:month>jul</b:month> + <b:year>2016</b:year> + <b:note>arXiv: 1211.6581</b:note> + <b:keywords>Computer Science - Learning</b:keywords> + <b:pages>55--98</b:pages> + <b:annote> + Comment: Accepted for publication in Machine Learning + journal. This replacement contains major improvements + compared to the previous version, including a deeper + theoretical and experimental analysis and an extended + discussion of related work. + </b:annote> + </b:article> + <b:article id="argyriou_multitask_nodate"> + <b:title>Multi-Task Feature Learning</b:title> + <!-- <b:abstract> --> + <!-- We present a method for learning a low-dimensional --> + <!-- representation which is shared across a set of multiple --> + <!-- related tasks. The method builds upon the wellknown 1-norm --> + <!-- regularization problem using a new regularizer which --> + <!-- controls the number of learned features common for all the --> + <!-- tasks. We show that this problem is equivalent to a convex --> + <!-- optimization problem and develop an iterative algorithm for --> + <!-- solving it. The algorithm has a simple interpretation: it --> + <!-- alternately performs a supervised and an unsupervised step, --> + <!-- where in the latter step we learn commonacross-tasks --> + <!-- representations and in the former step we learn task-specific --> + <!-- functions using these representations. We report experiments --> + <!-- on a simulated and a real data set which demonstrate that --> + <!-- the proposed method dramatically improves the performance --> + <!-- relative to learning each task independently. Our algorithm --> + <!-- can also be used, as a special case, to simply select – not --> + <!-- learn – a few common features across the tasks. --> + <!-- </b:abstract> --> + <b:language>en</b:language> + <b:author> + Argyriou, Andreas and Evgeniou, Theodoros and Pontil, + Massimiliano + </b:author> + <b:year>2007</b:year> + <b:journal> + Advances in neural information processing systems + </b:journal> + <b:pages>41--48</b:pages> + </b:article> + <b:article id="tibshirani1996regression"> + <b:title> + Regression shrinkage and selection via the lasso + </b:title> + <b:author>Tibshirani, Robert</b:author> + <b:journal> + Journal of the Royal Statistical Society: Series B + (Methodological) + </b:journal> + <b:volume>58</b:volume> + <b:number>1</b:number> + <b:pages>267--288</b:pages> + <b:year>1996</b:year> + <b:publisher>Wiley Online Library</b:publisher> + </b:article> + <b:article id="jalali_dirty_nodate"> + <b:title>A Dirty Model for Multi-task Learning</b:title> + <!-- <b:abstract> --> + <!-- We consider multi-task learning in the setting of multiple --> + <!-- linear regression, and where some relevant features could be --> + <!-- shared across the tasks. Recent research has studied the use --> + <!-- of ℓ1/ℓq norm block-regularizations with q \textgreater 1 --> + <!-- for such blocksparse structured problems, establishing --> + <!-- strong guarantees on recovery even under high-dimensional --> + <!-- scaling where the number of features scale with the number --> + <!-- of observations. However, these papers also caution that the --> + <!-- performance of such block-regularized methods are very --> + <!-- dependent on the extent to which the features are shared --> + <!-- across tasks. Indeed they show [8] that if the extent of --> + <!-- overlap is less than a threshold, or even if parameter --> + <!-- values in the shared features are highly uneven, then block --> + <!-- ℓ1/ℓq regularization could actually perform worse than --> + <!-- simple separate elementwise ℓ1 regularization. Since these --> + <!-- caveats depend on the unknown true parameters, we might not --> + <!-- know when and which method to apply. Even otherwise, we are --> + <!-- far away from a realistic multi-task setting: not only do --> + <!-- the set of relevant features have to be exactly the same --> + <!-- across tasks, but their values have to as well. --> + <!-- </b:abstract> --> + <b:language>en</b:language> + <b:author> + Jalali, Ali and Sanghavi, Sujay and Ruan, Chao and + Ravikumar, Pradeep K + </b:author> + <b:journal> + Advances in neural information processing systems + </b:journal> + <b:volume>23</b:volume> + <b:pages>964--972</b:pages> + <b:year>2010</b:year> + </b:article> + <b:article id="he_laplacian_nodate"> + <b:title>Laplacian Score for Feature Selection</b:title> + <!-- <b:abstract> --> + <!-- In supervised learning scenarios, feature selection has been --> + <!-- studied widely in the literature. Selecting features in --> + <!-- unsupervised learning scenarios is a much harder problem, --> + <!-- due to the absence of class labels that would guide the --> + <!-- search for relevant information. And, almost all of previous --> + <!-- unsupervised feature selection methods are “wrapper” --> + <!-- techniques that require a learning algorithm to evaluate the --> + <!-- candidate feature subsets. In this paper, we propose a --> + <!-- “filter” method for feature selection which is independent of --> + <!-- any learning algorithm. Our method can be performed in --> + <!-- either supervised or unsupervised fashion. The proposed --> + <!-- method is based on the observation that, in many real world --> + <!-- classification problems, data from the same class are often --> + <!-- close to each other. The importance of a feature is --> + <!-- evaluated by its power of locality preserving, or, Laplacian --> + <!-- Score. We compare our method with data variance --> + <!-- (unsupervised) and Fisher score (supervised) on two data --> + <!-- sets. Experimental results demonstrate the effectiveness and --> + <!-- efficiency of our algorithm. --> + <!-- </b:abstract> --> + <b:language>en</b:language> + <b:author> + He, Xiaofei and Cai, Deng and Niyogi, Partha + </b:author> + <b:journal> + Advances in neural information processing systems + </b:journal> + <b:volume>18</b:volume> + <b:pages>507--514</b:pages> + <b:year>2005</b:year> + </b:article> + <b:article id="malsar"> + <b:author>Zhou, Jiayu and Chen, J and Ye, J</b:author> + <b:year>2012</b:year> + <b:month>01</b:month> + <b:title>MALSAR: Multi-tAsk Learning via StructurAl Regularization</b:title> + </b:article> + <b:article id="zhu_multilabel_2017"> + <b:title> + Multi-Label Learning with Global and Local Label Correlation + </b:title> + <b:url>http://arxiv.org/abs/1704.01415</b:url> + <!-- <b:abstract> --> + <!-- It is well-known that exploiting label correlations is --> + <!-- important to multi-label learning. Existing approaches --> + <!-- either assume that the label correlations are global and --> + <!-- shared by all instances; or that the label correlations are --> + <!-- local and shared only by a data subset. In fact, in the --> + <!-- real-world applications, both cases may occur that some --> + <!-- label correlations are globally applicable and some are --> + <!-- shared only in a local group of instances. Moreover, it is --> + <!-- also a usual case that only partial labels are observed, --> + <!-- which makes the exploitation of the label correlations much --> + <!-- more difficult. That is, it is hard to estimate the label --> + <!-- correlations when many labels are absent. In this paper, we --> + <!-- propose a new multi-label approach GLOCAL dealing with both --> + <!-- the full-label and the missinglabel cases, exploiting global --> + <!-- and local label correlations simultaneously, through --> + <!-- learning a latent label representation and optimizing label --> + <!-- manifolds. The extensive experimental studies validate the --> + <!-- effectiveness of our approach on both full-label and --> + <!-- missing-label data. --> + <!-- </b:abstract> --> + <b:language>en</b:language> + <b:urldate>2020-09-17</b:urldate> + <b:journal> + IEEE Transactions on Knowledge and Data Engineering + </b:journal> + <b:author> + Zhu, Yue and Kwok, James T. and Zhou, Zhi-Hua + </b:author> + <b:month>apr</b:month> + <b:year>2017</b:year> + <b:note>arXiv: 1704.01415</b:note> + <b:keywords> + Computer Science - Machine Learning, Computer Science - + Artificial Intelligence + </b:keywords> + </b:article> + <b:article id="rank"> + <b:title>Convex Multi-Task Feature Learning</b:title> + <!-- <b:abstract> --> + <!-- We present a method for learning sparse representations --> + <!-- shared across multiple tasks. This method is a --> + <!-- generalization of the well-known singletask 1-norm --> + <!-- regularization. It is based on a novel non-convex --> + <!-- regularizer which controls the number of learned features --> + <!-- common across the tasks. We prove that the method is --> + <!-- equivalent to solving a convex optimization problem for --> + <!-- which there is an iterative algorithm which converges to an --> + <!-- optimal solution. The algorithm has a simple interpretation: --> + <!-- it alternately performs a supervised and an unsupervised --> + <!-- step, where in the former step it learns task-specific --> + <!-- functions and in the latter step it learns --> + <!-- common-across-tasks sparse representations for these --> + <!-- functions. We also provide an extension of the algorithm --> + <!-- which learns sparse nonlinear representations using --> + <!-- kernels. We report experiments on simulated and real data --> + <!-- sets which demonstrate that the proposed method can both --> + <!-- improve the performance relative to learning each task --> + <!-- independently and lead to a few learned features common --> + <!-- across related tasks. Our algorithm can also be used, as a --> + <!-- special case, to simply select – not learn – a few common --> + <!-- variables across the tasks. --> + <!-- </b:abstract> --> + <b:language>en</b:language> + <b:author> + Argyriou, Andreas and Evgeniou, Theodoros and Pontil, + Massimiliano + </b:author> + <b:journal>Machine learning</b:journal> + <b:volume>73</b:volume> + <b:number>3</b:number> + <b:pages>243--272</b:pages> + <b:year>2008</b:year> + <b:publisher>Springer</b:publisher> + </b:article> + <b:article id="zha_spectral_nodate"> + <b:title>Spectral Relaxation for K-means Clustering</b:title> + <!-- <b:abstract> --> + <!-- The popular K-means clustering partitions a data set by --> + <!-- minimizing a sum-of-squares cost function. A coordinate --> + <!-- descend method is then used to find local minima. In this --> + <!-- paper we show that the minimization can be reformulated as a --> + <!-- trace maximization problem associated with the Gram matrix --> + <!-- of the data vectors. Furthermore, we show that a relaxed --> + <!-- version of the trace maximization problem possesses global --> + <!-- optimal solutions which can be obtained by computing a --> + <!-- partial eigendecomposition of the Gram matrix, and the --> + <!-- cluster assignment for each data vectors can be found by --> + <!-- computing a pivoted QR decomposition of the eigenvector --> + <!-- matrix. As a by-product we also derive a lower bound for the --> + <!-- minimum of the sum-of-squares cost function. --> + <!-- </b:abstract> --> + <b:language>en</b:language> + <b:author> + Zha, Hongyuan and He, Xiaofeng and Ding, Chris and Gu, Ming + and Simon, Horst D + </b:author> + <b:journal> + Advances in neural information processing systems + </b:journal> + <b:volume>14</b:volume> + <b:pages>1057--1064</b:pages> + <b:year>2001</b:year> + </b:article> + <b:article id="cmtl"> + <b:title> + Clustered Multi-Task Learning Via Alternating Structure + Optimization + </b:title> + <!-- <b:abstract> --> + <!-- Multi-task learning (MTL) learns multiple related tasks --> + <!-- simultaneously to improve generalization --> + <!-- performance. Alternating structure optimization (ASO) is a --> + <!-- popular MTL method that learns a shared low-dimensional --> + <!-- predictive structure on hypothesis spaces from multiple --> + <!-- related tasks. It has been applied successfully in many real --> + <!-- world applications. As an alternative MTL approach, --> + <!-- clustered multi-task learning (CMTL) assumes that multiple --> + <!-- tasks follow a clustered structure, i.e., tasks are --> + <!-- partitioned into a set of groups where tasks in the same --> + <!-- group are similar to each other, and that such a clustered --> + <!-- structure is unknown a priori. The objectives in ASO and --> + <!-- CMTL differ in how multiple tasks are --> + <!-- related. Interestingly, we show in this paper the --> + <!-- equivalence relationship between ASO and CMTL, providing --> + <!-- significant new insights into ASO and CMTL as well as their --> + <!-- inherent relationship. The CMTL formulation is non-convex, --> + <!-- and we adopt a convex relaxation to the CMTL formulation. We --> + <!-- further establish the equivalence relationship between the --> + <!-- proposed convex relaxation of CMTL and an existing convex --> + <!-- relaxation of ASO, and show that the proposed convex CMTL --> + <!-- formulation is significantly more efficient especially for --> + <!-- high-dimensional data. In addition, we present three --> + <!-- algorithms for solving the convex CMTL formulation. We --> + <!-- report experimental results on benchmark datasets to --> + <!-- demonstrate the efficiency of the proposed algorithms. --> + <!-- </b:abstract> --> + <b:language>en</b:language> + <b:author> + Zhou, Jiayu and Chen, Jianhui and Ye, Jieping + </b:author> + <b:journal> + Advances in neural information processing systems + </b:journal> + <b:volume>24</b:volume> + <b:pages>702--710</b:pages> + <b:year>2011</b:year> + </b:article> + <b:article id="cappedl1"> + <b:title>Analysis of multi-stage convex relaxation for sparse regularization.</b:title> + <b:author>Zhang, Tong</b:author> + <b:journal>Journal of Machine Learning Research</b:journal> + <b:volume>11</b:volume> + <b:number>3</b:number> + <b:year>2010</b:year> + </b:article> + <b:inproceedings id="msmtfl"> + <b:title>Multi-stage multi-task feature learning</b:title> + <b:author>Gong, Pinghua and Ye, Jieping and Zhang, Chang-shui</b:author> + <b:booktitle>Advances in neural information processing systems</b:booktitle> + <b:pages>1988--1996</b:pages> + <b:year>2012</b:year> + </b:inproceedings> + <b:inproceedings id="msmtflrank"> + <b:title>Multi-Stage Multi-Task Learning with Reduced Rank.</b:title> + <b:author>Han, Lei and Zhang, Yu</b:author> + <b:booktitle>Proceedings of the Thirtieth AAAI Conference on Artificial Intelligence</b:booktitle> + <b:pages>1638--1644</b:pages> + <b:year>2016</b:year> + </b:inproceedings> + <b:article id="l21m2"> + <b:title> + Feature Selection With <h:eq>\ell_{2,1-2}</h:eq> Regularization + </b:title> + <b:volume>29</b:volume> + <b:issn>2162-237X, 2162-2388</b:issn> + <b:url>https://ieeexplore.ieee.org/document/8259312/</b:url> + <b:doi>10.1109/TNNLS.2017.2785403</b:doi> + <b:abstract> + Feature selection aims to select a subset of features from + high-dimensional data according to a predefined selecting + criterion. Sparse learning has been proven to be a powerful + technique in feature selection. Sparse regularizer, as a key + component of sparse learning, has been studied for several + years. Although convex regularizers have been used in many + works, there are some cases where nonconvex regularizers + outperform convex regularizers. To make the process of + selecting relevant features more effective, we propose a + novel nonconvex sparse metric on matrices as the sparsity + regularization in this paper. The new nonconvex regularizer + could be written as the difference of + the <h:eq>\ell_{2,1}</h:eq> norm and the + Frobenius <h:eq>\ell_{2,2}</h:eq> norm, which is named the + <h:eq>\ell_{2,1-2}</h:eq>. To find the solution of the + resulting nonconvex formula, we design an iterative + algorithm in the framework of ConCave–Convex Procedure + (CCCP) and prove its strong global convergence. An adopted + alternating direction method of multipliers is embedded to + solve the sequence of convex subproblems in CCCP + efficiently. Using the scaled cluster indictors of data + points as pseudolabels, we also + apply <h:eq>\ell_{2,1-2}</h:eq> to the unsupervised case. To + the best of our knowledge, it is the first work considering + nonconvex regularization for matrices in the unsupervised + learning scenario. Numerical experiments are performed on + realworld data sets to demonstrate the effectiveness of the + proposed method. + </b:abstract> + <b:language>en</b:language> + <b:number>10</b:number> + <b:urldate>2020-09-20</b:urldate> + <b:journal> + IEEE Trans. Neural Netw. Learning Syst. + </b:journal> + <b:author> + Shi, Yong and Miao, Jianyu and Wang, Zhengyu and Zhang, Peng + and Niu, Lingfeng + </b:author> + <b:month>oct</b:month> + <b:year>2018</b:year> + <b:pages>4967--4982</b:pages> + </b:article> + <b:article id="li_convex_2013"> + <b:title>Convex and scalable weakly labeled svms</b:title> + <b:volume>14</b:volume> + <b:url>http://www.jmlr.org/papers/volume14/li13a/li13a.pdf</b:url> + <b:number>1</b:number> + <b:urldate>2017-10-09</b:urldate> + <b:journal>The Journal of Machine Learning Research</b:journal> + <b:author> + Li, Yu-Feng and Tsang, Ivor W. and Kwok, James T. and Zhou, + Zhi-Hua + </b:author> + <b:year>2013</b:year> + <b:pages>2151--2188</b:pages> + </b:article> + <b:book id="basu_constrained_2009"> + <b:address>Boca Raton</b:address> + <b:series> + Chapman & Hall/CRC data mining and knowledge discovery + series + </b:series> + <b:title> + Constrained clustering: advances in algorithms, theory, and applications + </b:title> + <b:isbn>978-1-58488-996-0</b:isbn> + <b:shorttitle>Constrained clustering</b:shorttitle> + <b:publisher>CRC Press</b:publisher> + <b:editor> + Basu, Sugato and Davidson, Ian and Wagstaff, Kiri Lou + </b:editor> + <b:year>2009</b:year> + <b:note>OCLC: ocn144226504</b:note> + <b:keywords> + Cluster analysis, Computer algorithms, Data mining, Data + processing + </b:keywords> + <b:annote>A Chapman & Hall book."</b:annote> + </b:book> + <b:inproceedings id="joachims1999transductive"> + <b:title> + Transductive inference for text classification using support + vector machines + </b:title> + <b:author>Joachims, Thorsten</b:author> + <b:booktitle>ICML</b:booktitle> + <b:volume>99</b:volume> + <b:pages>200--209</b:pages> + <b:year>1999</b:year> + </b:inproceedings> + <b:inproceedings id="blum_learning_2001"> + <b:address>San Francisco, CA, USA</b:address> + <b:series>ICML '01</b:series> + <b:title> + Learning from Labeled and Unlabeled Data Using Graph Mincuts + </b:title> + <b:isbn>1-55860-778-1</b:isbn> + <b:url>http://dl.acm.org/citation.cfm?id=645530.757779</b:url> + <b:booktitle> + Proceedings of the Eighteenth International Conference on + Machine Learning + </b:booktitle> + <b:publisher>Morgan Kaufmann Publishers Inc.</b:publisher> + <b:author>Blum, Avrim and Chawla, Shuchi</b:author> + <b:year>2001</b:year> + <b:pages>19--26</b:pages> + </b:inproceedings> + <b:article id="nigam2000text"> + <b:title> + Text classification from labeled and unlabeled documents + using EM + </b:title> + <b:author> + Nigam, Kamal and McCallum, Andrew Kachites and Thrun, + Sebastian and Mitchell, Tom + </b:author> + <b:journal>Machine learning</b:journal> + <b:volume>39</b:volume> + <b:number>2</b:number> + <b:pages>103--134</b:pages> + <b:year>2000</b:year> + <b:publisher>Springer</b:publisher> + </b:article> + <b:article id="azriel_semi-supervised_2016"> + <b:title>Semi-Supervised linear regression</b:title> + <b:journal>arXiv preprint arXiv:1612.02391</b:journal> + <b:author> + Azriel, David and Brown, Lawrence D and Sklar, Michael and + Berk, Richard and Buja, Andreas and Zhao, Linda + </b:author> + <b:year>2016</b:year> + </b:article> + <b:inproceedings id="amini_semi-supervised_2002"> + <b:address> + Amsterdam, The Netherlands, The Netherlands + </b:address> + <b:series>ECAI'02</b:series> + <b:title> + Semi-supervised Logistic Regression + </b:title> + <b:isbn>978-1-58603-257-9</b:isbn> + <b:url>http://dl.acm.org/citation.cfm?id=3000905.3000988</b:url> + <b:booktitle> + Proceedings of the 15th European Conference on Artificial + Intelligence + </b:booktitle> + <b:publisher>IOS Press</b:publisher> + <b:author>Amini, Massih-Reza and Gallinari, Patrick</b:author> + <b:year>2002</b:year> + <b:keywords> + machine learning, semi-supervised learning + </b:keywords> + <b:pages>390--394</b:pages> + </b:inproceedings> + <b:techreport id="cai_semi-supervised_2006"> + <b:title>Semi-supervised regression using spectral techniques</b:title> + <b:author>Cai, Deng and He, Xiaofei and Han, Jiawei</b:author> + <b:year>2006</b:year> + </b:techreport> + <b:article id="zhou_semi-supervised_nodate"> + <b:title> + Semi-Supervised Regression with Co-Training + </b:title> + <!-- <b:abstract> --> + <!-- In many practical machine learning and data mining --> + <!-- applications, unlabeled training examples are readily --> + <!-- available but labeled ones are fairly expensive to --> + <!-- obtain. Therefore, semi-supervised learning algorithms such --> + <!-- as co-training have attracted much attention. Previous --> + <!-- research mainly focuses on semi-supervised --> + <!-- classification. In this paper, a co-training style --> + <!-- semi-supervised regression algorithm, i.e. COREG, is --> + <!-- proposed. This algorithm uses two k-nearest neighbor --> + <!-- regressors with different distance metrics, each of which --> + <!-- labels the unlabeled data for the other regressor where the --> + <!-- labeling confidence is estimated through consulting the --> + <!-- influence of the labeling of unlabeled examples on the --> + <!-- labeled ones. Experiments show that COREG can effectively --> + <!-- exploit unlabeled data to improve regression estimates. --> + <!-- </b:abstract> --> + <b:language>en</b:language> + <b:author>Zhou, Zhi-Hua and Li, Ming</b:author> + <b:pages>6</b:pages> + </b:article> + <b:article id="ryan_semi-supervised_2015"> + <b:title> + On semi-supervised linear regression in covariate shift + problems. + </b:title> + <b:volume>16</b:volume> + <b:url>http://www.jmlr.org/papers/volume16/ryan15a/ryan15a.pdf</b:url> + <b:urldate>2017-10-10</b:urldate> + <b:journal>Journal of Machine Learning Research</b:journal> + <b:author>Ryan, Kenneth Joseph and Culp, Mark Vere</b:author> + <b:year>2015</b:year> + <b:pages>3183--3217</b:pages> + </b:article> + <b:article id="moscovich_minimax-optimal_nodate"> + <b:author> + Amit Moscovich and Ariel Jaffe and Boaz Nadler + </b:author> + <b:editor> + Aarti Singh and Xiaojin (Jerry) Zhu + </b:editor> + <b:title> + Minimax-optimal semi-supervised regression on unknown + manifolds + </b:title> + <b:booktitle> + Proceedings of the 20th International Conference on + Artificial Intelligence and Statistics + </b:booktitle> + <b:series>Proceedings of Machine Learning Research</b:series> + <b:volume>54</b:volume> + <b:pages>933--942</b:pages> + <b:publisher>PMLR}</b:publisher> + <b:year>2017</b:year> + </b:article> + <b:inproceedings id="ho1995random"> + <b:title>Random decision forests</b:title> + <b:author>Ho, Tin Kam</b:author> + <b:booktitle> + Proceedings of 3rd international conference on document + analysis and recognition + </b:booktitle> + <b:volume>1</b:volume> + <b:pages>278--282</b:pages> + <b:year>1995</b:year> + <b:organization>IEEE</b:organization> + </b:inproceedings> + <b:article id="nusvm"> + <b:title>New support vector algorithms</b:title> + <b:author> + Schölkopf, Bernhard and Smola, Alex J and Williamson, Robert + C and Bartlett, Peter L + </b:author> + <b:journal>Neural computation</b:journal> + <b:volume>12</b:volume> + <b:number>5</b:number> + <b:pages>1207--1245</b:pages> + <b:year>2000</b:year> + <b:publisher>MIT Press</b:publisher> + </b:article> + <b:article id="davies2001factors"> + <b:title> + Factors influencing the structural deterioration and + collapse of rigid sewer pipes + </b:title> + <b:author> + Davies, JP and Clarke, BA and Whiter, JT and Cunningham, RJ + </b:author> + <b:journal>Urban water</b:journal> + <b:volume>3</b:volume> + <b:number>1-2</b:number> + <b:pages>73--89</b:pages> + <b:year>2001</b:year> + <b:publisher>Elsevier</b:publisher> + </b:article> + <b:article id="ahmadi_2014_influence"> + <b:author> + Mehdi Ahmadi and Frédéric Cherqui and Jean-Christophe De + Massiac and Pascal Le Gauffre + </b:author> + <b:title> + Influence of available data on sewer inspection program + efficiency + </b:title> + <b:journal>Urban Water Journal</b:journal> + <b:volume>11</b:volume> + <b:number>8</b:number> + <b:pages>641-656</b:pages> + <b:year >2014</b:year> + <b:doi>10.1080/1573062X.2013.831910</b:doi> + </b:article> + <b:article id="harvey2014predicting"> + <b:author>Harvey, Robert Richard and McBean, Edward Arthur</b:author> + <b:title> + Predicting the structural condition of individual sanitary + sewer pipes with random forests + </b:title> + <b:journal>Canadian Journal of Civil Engineering</b:journal> + <b:volume>41</b:volume> + <b:number>4</b:number> + <b:pages>294-303</b:pages> + <b:year>2014</b:year> + <b:doi>10.1139/cjce-2013-0431</b:doi> + <b:url>https://doi.org/10.1139/cjce-2013-0431</b:url> + </b:article> + <b:article id="zhao_learning_2015"> + <b:title> + Learning from normalized local and global discriminative + information for semi-supervised regression and + dimensionality reduction + </b:title> + <b:volume>324</b:volume> + <b:issn>00200255</b:issn> + <b:url>http://linkinghub.elsevier.com/retrieve/pii/S0020025515004533</b:url> + <b:doi>10.1016/j.ins.2015.06.021</b:doi> + <b:language>en</b:language> + <b:urldate>2018-08-14</b:urldate> + <b:journal>Information Sciences</b:journal> + <b:author> + Zhao, Mingbo and Chow, Tommy W.S. and Wu, Zhou and Zhang, + Zhao and Li, Bing + </b:author> + <b:month>dec</b:month> + <b:year>2015</b:year> + <b:pages>286--309</b:pages> + </b:article> + <b:article id="zhang2012trace"> + <b:title> + Trace ratio optimization-based semi-supervised nonlinear + dimensionality reduction for marginal manifold visualization + </b:title> + <b:author> + Zhang, Zhao and Chow, Tommy WS and Zhao, Mingbo + </b:author> + <b:journal> + IEEE Transactions on Knowledge and Data Engineering + </b:journal> + <b:volume>25</b:volume> + <b:number>5</b:number> + <b:pages>1148--1161</b:pages> + <b:year>2012</b:year> + <b:publisher>IEEE</b:publisher> + </b:article> + <b:inproceedings id="gasse_optimality_2015"> + <b:address>Lille, France</b:address> + <b:series>Journal of Machine Learning Reasearch Proceedings</b:series> + <b:title>On the Optimality of Multi-Label Classification under Subset Zero-One Loss for Distributions Satisfying the Composition Property</b:title> + <b:volume>37</b:volume> + <b:url>https://hal.archives-ouvertes.fr/hal-01234346</b:url> + <b:booktitle>International Conference on Machine Learning</b:booktitle> + <b:author>Gasse, Maxime and Aussem, Alex and Elghazel, Haytham</b:author> + <b:editor>Bach, Francis R. and Blei, David M.</b:editor> + <b:month>jul</b:month> + <b:year>2015</b:year> + <b:pages>2531--2539</b:pages> + </b:inproceedings> + <b:article id="borchani_survey_2015"> + <b:title>A survey on multi-output regression</b:title> + <b:volume>5</b:volume> + <b:url>http://onlinelibrary.wiley.com/doi/10.1002/widm.1157/full</b:url> + <b:number>5</b:number> + <b:urldate>2017-10-11</b:urldate> + <b:journal>Wiley Interdisciplinary Reviews: Data Mining and Knowledge Discovery</b:journal> + <b:author>Borchani, Hanen and Varando, Gherardo and Bielza, Concha and Larrañaga, Pedro</b:author> + <b:year>2015</b:year> + <b:pages>216--233</b:pages> + </b:article> + <b:article id="read2011classifier"> + <b:title>Classifier chains for multi-label classification</b:title> + <b:author>Read, Jesse and Pfahringer, Bernhard and Holmes, Geoff and Frank, Eibe</b:author> + <b:journal>Machine learning</b:journal> + <b:volume>85</b:volume> + <b:number>3</b:number> + <b:pages>333</b:pages> + <b:year>2011</b:year> + <b:publisher>Springer</b:publisher> + </b:article> + <b:article id="liu_easy--hard_2017"> + <b:title>An easy-to-hard learning paradigm for multiple classes and multiple labels</b:title> + <b:volume>18</b:volume> + <b:number>1</b:number> + <b:journal>The Journal of Machine Learning Research</b:journal> + <b:author>Liu, Weiwei and Tsang, Ivor W. and Müller, Klaus-Robert</b:author> + <b:year>2017</b:year> + <b:pages>3300--3337</b:pages> + </b:article> + <b:inproceedings id="yu_learning_2005"> + <b:title>Learning Gaussian processes from multiple tasks</b:title> + <b:booktitle>Proceedings of the 22nd international conference on Machine learning</b:booktitle> + <b:publisher>ACM</b:publisher> + <b:author>Yu, Kai and Tresp, Volker and Schwaighofer, Anton</b:author> + <b:year>2005</b:year> + <b:pages>1012--1019</b:pages> + </b:inproceedings> + <b:incollection id="chen_feature-aware_2012"> + <b:title>Feature-aware Label Space Dimension Reduction for Multi-label Classification</b:title> + <b:url>http://papers.nips.cc/paper/4561-feature-aware-label-space-dimension-reduction-for-multi-label-classification.pdf</b:url> + <b:booktitle>Advances in Neural Information Processing Systems 25</b:booktitle> + <b:publisher>Curran Associates, Inc.</b:publisher> + <b:author>Chen, Yao-nan and Lin, Hsuan-tien</b:author> + <b:editor>Pereira, F. and Burges, C. J. C. and Bottou, L. and Weinberger, K. Q.</b:editor> + <b:year>2012</b:year> + <b:pages>1529--1537</b:pages> + </b:incollection> + <b:inproceedings id="luo_adaptive_2017"> + <b:title>Adaptive Semi-Supervised Learning with Discriminative Least Squares Regression</b:title> + <b:isbn>978-0-9992411-0-3</b:isbn> + <b:url>https://www.ijcai.org/proceedings/2017/337</b:url> + <b:doi>10.24963/ijcai.2017/337</b:doi> + <b:language>en</b:language> + <b:urldate>2017-10-10</b:urldate> + <b:publisher>International Joint Conferences on Artificial Intelligence Organization</b:publisher> + <b:author>Luo, Minnan and Zhang, Lingling and Nie, Feiping and Chang, Xiaojun and Qian, Buyue and Zheng, Qinghua</b:author> + <b:month>aug</b:month> + <b:year>2017</b:year> + <b:pages>2421--2427</b:pages> + </b:inproceedings> + <b:article id="agd"> + <b:author>Nesterov, Yu</b:author> + <b:year>2007</b:year> + <b:month>01</b:month> + <b:pages></b:pages> + <b:title> + Gradient methods for minimizing composite functions + </b:title> + <b:volume>140</b:volume> + <b:journal> + Université catholique de Louvain, Center for Operations + Research and Econometrics (CORE), CORE Discussion Papers + </b:journal> + <b:doi>10.1007/s10107-012-0629-</b:doi> + </b:article> + <b:article id="randomsearch"> + <b:author>James Bergstra and Yoshua Bengio</b:author> + <b:title>Random Search for Hyper-Parameter Optimization</b:title> + <b:journal>Journal of Machine Learning Research</b:journal> + <b:year>2012</b:year> + <b:volume>13</b:volume> + <b:number>10</b:number> + <b:pages>281-305</b:pages> + <b:url>http://jmlr.org/papers/v13/bergstra12a.html</b:url> + </b:article> + <b:article id="demsar_statistical_2006"> + <b:title>Statistical Comparisons of Classifiers over Multiple Data Sets</b:title> + <b:volume>7</b:volume> + <b:issn>1532-4435</b:issn> + <b:url>http://dl.acm.org/citation.cfm?id=1248547.1248548</b:url> + <b:journal>Journal of machine learning research</b:journal> + <b:author>Demšar, Janez</b:author> + <b:month>dec</b:month> + <b:year>2006</b:year> + <b:pages>1--30</b:pages> + </b:article> + <b:inproceedings id="robust"> + <b:author>Chen, Jianhui and Zhou, Jiayu and Ye, Jieping</b:author> + <b:year>2011</b:year> + <b:month>08</b:month> + <b:pages>42--50</b:pages> + <b:title> + Integrating low-rank and group-sparse structures for robust + multi-task learning + </b:title> + <b:doi>10.1145/2020408.2020423</b:doi> + <b:booktitle> + Proceedings of the 17th ACM SIGKDD International Conference + on Knowledge Discovery and Data Mining + </b:booktitle> + </b:inproceedings> + <b:article id="sfus"> + <b:title> + Web image annotation via subspace-sparsity collaborated + feature selection + </b:title> + <b:author> + Ma, Zhigang + and Nie, Feiping + and Yang, Yi + and Uijlings, Jasper RR + and Sebe, Nicu + </b:author> + <b:journal>IEEE Transactions on Multimedia</b:journal> + <b:volume>14</b:volume> + <b:number>4</b:number> + <b:pages>1021--1030</b:pages> + <b:year>2012</b:year> + <b:publisher>IEEE</b:publisher> + </b:article> + <b:incollection id="rfs"> + <b:title> + Efficient and Robust Feature Selection via + Joint <h:eq>\ell_{2,1}</h:eq>-Norms Minimization + </b:title> + <b:url>http://papers.nips.cc/paper/3988-efficient-and-robust-feature-selection-via-joint-l21-norms-minimization.pdf</b:url> + <b:booktitle> + Advances in Neural Information Processing Systems 23 + </b:booktitle> + <b:publisher>Curran Associates, Inc.</b:publisher> + <b:author> + Nie, Feiping + and Huang, Heng + and Cai, Xiao + and Ding, Chris H. + </b:author> + <b:editor> + Lafferty, J. D. + and Williams, C. K. I. + and Shawe-Taylor, J. + and Zemel, R. S. + and Culotta, A. + </b:editor> + <b:year>{2010}</b:year> + <b:pages>{1813--1821}</b:pages> + </b:incollection> + <b:article id="lanczos"> + <b:author>Lanczos, Cornelius</b:author> + <b:year>1950</b:year> + <b:month>10</b:month> + <b:pages></b:pages> + <b:title> + An Iteration Method for the solution of the Eigenvalue + Problem of Linear Differential and Integral Operators + </b:title> + <b:volume>45</b:volume> + <b:journal> + Journal of Research of the National Bureau of Standards + </b:journal> + <b:doi>10.6028/jres.045.026</b:doi> + </b:article> + <b:article id="Breiman1996"> + <b:author>Breiman, Leo</b:author> + <b:title>Bagging Predictors</b:title> + <b:journal>Machine Learning</b:journal> + <b:year>1996</b:year> + <b:month>Aug</b:month> + <!-- <b:day>01</b:day> --> + <b:volume>24</b:volume> + <b:number>2</b:number> + <b:pages>123-140</b:pages> + <b:abstract> + Bagging predictors is a method for generating multiple + versions of a predictor and using these to get an aggregated + predictor. The aggregation averages over the versions when + predicting a numerical outcome and does a plurality vote + when predicting a class. The multiple versions are formed by + making bootstrap replicates of the learning set and using + these as new learning sets. Tests on real and simulated data + sets using classification and regression trees and subset + selection in linear regression show that bagging can give + substantial gains in accuracy. The vital element is the + instability of the prediction method. If perturbing the + learning set can cause significant changes in the predictor + constructed, then bagging can improve accuracy. + </b:abstract> + <b:issn>1573-0565</b:issn> + <b:doi>10.1023/A:1018054314350</b:doi> + <b:url>https://doi.org/10.1023/A:1018054314350</b:url> + </b:article> + <b:article id="stacking"> + <b:author>Wolpert, David</b:author> + <b:year>1992</b:year> + <b:month>12</b:month> + <b:pages>241-259</b:pages> + <b:title>Stacked Generalization</b:title> + <b:volume>5</b:volume> + <b:journal>Neural Networks</b:journal> + <b:doi>10.1016/S0893-6080(05)80023-1</b:doi> + </b:article> + <b:article id="alexnet"> + <b:title>Imagenet classification with deep convolutional neural networks</b:title> + <b:author>Krizhevsky, Alex and Sutskever, Ilya and Hinton, Geoffrey E</b:author> + <b:journal>Communications of the ACM</b:journal> + <b:volume>60</b:volume> + <b:number>6</b:number> + <b:pages>84--90</b:pages> + <b:year>2017</b:year> + <b:publisher>ACM New York, NY, USA</b:publisher> + </b:article> + </h:bibliography> + </body> +</html> diff --git a/manuscrit.xsl b/manuscrit.xsl new file mode 100644 index 0000000..15d10fa --- /dev/null +++ b/manuscrit.xsl @@ -0,0 +1,129 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsl:stylesheet + version="1.0" + xmlns:xsl="http://www.w3.org/1999/XSL/Transform" + xmlns:html="http://www.w3.org/1999/xhtml" + xmlns:m="http://planete-kraus.eu/ns/manuscrit"> + + <xsl:import href="http://h4sp.planete-kraus.eu/transform/latex.xsl" /> + + <xsl:output method="text" indent="no"/> + <xsl:strip-space elements="*" /> + + <xsl:template match="/"> + <xsl:variable name="auteur"> + <xsl:variable name="espacé"> + <xsl:apply-templates select="/html:html/html:head/m:author" /> + </xsl:variable> + <xsl:value-of select="normalize-space($espacé)" /> + </xsl:variable> + <xsl:variable name="titre"> + <xsl:variable name="espacé"> + <xsl:apply-templates select="/html:html/html:head/html:title" /> + </xsl:variable> + <xsl:value-of select="normalize-space($espacé)" /> + </xsl:variable> + <xsl:text>\documentclass[11pt,a4paper,twoside,openright]{book}
</xsl:text> + <xsl:text>\usepackage[utf8]{inputenc}
</xsl:text> + <xsl:text>\usepackage[T1]{fontenc}
</xsl:text> + <xsl:text>\usepackage[french]{babel}
</xsl:text> + <xsl:text>\usepackage{graphicx}
</xsl:text> + <xsl:text>\usepackage{grffile}
</xsl:text> + <xsl:text>\usepackage{longtable}
</xsl:text> + <xsl:text>\usepackage{wrapfig}
</xsl:text> + <xsl:text>\usepackage{rotating}
</xsl:text> + <xsl:text>\usepackage[normalem]{ulem}
</xsl:text> + <xsl:text>\usepackage{amsmath}
</xsl:text> + <xsl:text>\usepackage{textcomp}
</xsl:text> + <xsl:text>\usepackage{amssymb}
</xsl:text> + <xsl:text>\usepackage{capt-of}
</xsl:text> + <xsl:text>\usepackage{hyperref}
</xsl:text> + <xsl:text>\usepackage{optidef}
</xsl:text> + <xsl:text>\usepackage{tikz}
</xsl:text> + <xsl:text>\usepackage{subcaption}
</xsl:text> + <xsl:text>\usepackage{geometry}
</xsl:text> + <xsl:text>\usepackage{import}
</xsl:text> + <xsl:text>\usepackage{caption}
</xsl:text> + <xsl:text>\usepackage{algorithm}
</xsl:text> + <xsl:text>\usepackage{algorithmicx}
</xsl:text> + <xsl:text>\usepackage{algpseudocode}
</xsl:text> + <xsl:text>\usepackage{pdfpages}
</xsl:text> + <xsl:text>\usepackage{svg}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\author{</xsl:text><xsl:value-of select="$auteur" /><xsl:text>}
</xsl:text> + <xsl:text>\title{</xsl:text><xsl:value-of select="$titre" /><xsl:text>}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\begin{document}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\makeatletter
</xsl:text> + <xsl:text>\@ifundefined{srcdir}{}{
</xsl:text> + <xsl:text> \graphicspath{{\srcdir}}
</xsl:text> + <xsl:text> \newcommand{\insrcdir}[1]{\srcdir#1}
</xsl:text> + <xsl:text> \let\oldpgfimage\pgfimage
</xsl:text> + <xsl:text> \renewcommand{\pgfimage}[2][]{\oldpfgfimage[#1]{\insrcdir{images/#2}}}
</xsl:text> + <xsl:text>}
</xsl:text> + <xsl:text>\makeatother
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\let\mylistof\listof
</xsl:text> + <xsl:text>\renewcommand\listof[2]{\mylistof{algorithm}{Liste des algorithmes}}
</xsl:text> + <xsl:text>\makeatletter
</xsl:text> + <xsl:text>\providecommand*{\toclevel@algorithm}{0}
</xsl:text> + <xsl:text>\makeatother
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\includepdf{page-de-garde.pdf}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:apply-templates /> + <xsl:text>\end{document}
</xsl:text> + </xsl:template> + + <xsl:template match="m:résumé"> + <xsl:text>\section*{Résumé}
</xsl:text> + <xsl:apply-templates /> + </xsl:template> + + <xsl:template match="m:mots-clés"> + <xsl:text>
</xsl:text> + <xsl:text>\vspace{1cm}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\textbf{Mots-clés}~: 
</xsl:text> + <xsl:apply-templates /> + <xsl:text>
</xsl:text> + <xsl:text>\clearpage
</xsl:text> + <xsl:text>
</xsl:text> + </xsl:template> + + <xsl:template match="m:mot-clé[position() = last()]"> + <xsl:apply-templates /><xsl:text>.
</xsl:text> + </xsl:template> + + <xsl:template match="m:mot-clé"> + <xsl:apply-templates /><xsl:text>, </xsl:text> + </xsl:template> + + <xsl:template match="m:abstract"> + <xsl:text>\section*{Abstract}
</xsl:text> + <xsl:apply-templates /> + </xsl:template> + + <xsl:template match="m:keywords"> + <xsl:text>
</xsl:text> + <xsl:text>\vspace{1cm}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\textbf{Keywords}~: 
</xsl:text> + <xsl:apply-templates /> + <xsl:text>
</xsl:text> + <xsl:text>\cleardoublepage
</xsl:text> + <xsl:text>
</xsl:text> + </xsl:template> + + <xsl:template match="m:keyword[position() = last()]"> + <xsl:apply-templates /><xsl:text>.
</xsl:text> + </xsl:template> + + <xsl:template match="m:keyword"> + <xsl:apply-templates /><xsl:text>, </xsl:text> + </xsl:template> + + <xsl:template match="html:head"> + </xsl:template> +</xsl:stylesheet> diff --git a/page-de-garde.xsl b/page-de-garde.xsl new file mode 100644 index 0000000..f0c20fd --- /dev/null +++ b/page-de-garde.xsl @@ -0,0 +1,168 @@ +<?xml version="1.0" encoding="utf-8"?> +<xsl:stylesheet + version="1.0" + xmlns:xsl="http://www.w3.org/1999/XSL/Transform" + xmlns:html="http://www.w3.org/1999/xhtml" + xmlns:m="http://planete-kraus.eu/ns/manuscrit"> + + <xsl:import href="http://h4sp.planete-kraus.eu/transform/latex.xsl" /> + + <xsl:output method="text"/> + + <xsl:template match="/"> + <xsl:variable name="numéro-ordre-nnt"> + <xsl:variable name="espacé"> + <xsl:apply-templates select="/html:html/html:head/m:page-de-garde/m:numéro-ordre-nnt" /> + </xsl:variable> + <xsl:value-of select="normalize-space($espacé)" /> + </xsl:variable> + <xsl:variable name="page-de-garde-titre"> + <xsl:variable name="espacé"> + <xsl:apply-templates select="/html:html/html:head/m:page-de-garde/m:page-de-garde-titre" /> + </xsl:variable> + <xsl:value-of select="normalize-space($espacé)" /> + </xsl:variable> + <xsl:variable name="l-université"> + <xsl:variable name="espacé"> + <xsl:apply-templates select="/html:html/html:head/m:page-de-garde/m:l-université" /> + </xsl:variable> + <xsl:value-of select="normalize-space($espacé)" /> + </xsl:variable> + <xsl:variable name="école-doctorale"> + <xsl:variable name="espacé"> + <xsl:apply-templates select="/html:html/html:head/m:page-de-garde/m:école-doctorale" /> + </xsl:variable> + <xsl:value-of select="normalize-space($espacé)" /> + </xsl:variable> + <xsl:variable name="spécialité"> + <xsl:variable name="espacé"> + <xsl:apply-templates select="/html:html/html:head/m:page-de-garde/m:spécialité" /> + </xsl:variable> + <xsl:value-of select="normalize-space($espacé)" /> + </xsl:variable> + <xsl:variable name="date-soutenance"> + <xsl:variable name="espacé"> + <xsl:apply-templates select="/html:html/html:head/m:page-de-garde/m:date-soutenance" /> + </xsl:variable> + <xsl:value-of select="normalize-space($espacé)" /> + </xsl:variable> + <xsl:variable name="auteur"> + <xsl:variable name="espacé"> + <xsl:apply-templates select="/html:html/html:head/m:author" /> + </xsl:variable> + <xsl:value-of select="normalize-space($espacé)" /> + </xsl:variable> + <xsl:variable name="titre"> + <xsl:variable name="espacé"> + <xsl:apply-templates select="/html:html/html:head/html:title" /> + </xsl:variable> + <xsl:value-of select="normalize-space($espacé)" /> + </xsl:variable> + <xsl:text>\documentclass[11pt,a4paper]{book}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\usepackage[utf8]{inputenc}
</xsl:text> + <xsl:text>\usepackage[T1]{fontenc}
</xsl:text> + <xsl:text>\usepackage{graphicx}
</xsl:text> + <xsl:text>\usepackage[french]{babel}
</xsl:text> + <xsl:text>\usepackage[inner=2.5cm, outer=2.5cm, top=2.5cm, bottom=2.5cm]{geometry}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\makeatletter
</xsl:text> + <xsl:text>\@ifundefined{srcdir}{}{
</xsl:text> + <xsl:text> \graphicspath{{\srcdir}}
</xsl:text> + <xsl:text>}
</xsl:text> + <xsl:text>\makeatother
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\begin{document}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\setlength{\parindent}{0pt}
</xsl:text> + <xsl:text>\thispagestyle{empty}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\begin{center}
</xsl:text> + <xsl:text>\includegraphics[height=3cm]{images/the-logo.png}
</xsl:text> + <xsl:text>\end{center}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\fontsize{11pt}{13pt}\selectfont
</xsl:text> + <xsl:text>N\textsuperscript{o} d’ordre NNT~: </xsl:text><xsl:value-of select="$numéro-ordre-nnt" /><xsl:text>
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\vspace{1cm}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\begin{center}
</xsl:text> + <xsl:text>\fontsize{14pt}{16pt}\selectfont
</xsl:text> + <xsl:text>\textbf{\uppercase{</xsl:text><xsl:value-of select="$page-de-garde-titre" /><xsl:text>}}\\
</xsl:text> + <xsl:text>\fontsize{12pt}{14pt}\selectfont
</xsl:text> + <xsl:text>opérée au sein de\\
</xsl:text> + <xsl:text>\textbf{</xsl:text><xsl:value-of select="$l-université" /><xsl:text>}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\vspace{0.5cm}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\textbf{</xsl:text><xsl:value-of select="$école-doctorale" /><xsl:text>}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\vspace{0.5cm}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\textbf{Spécialité de doctorat~: </xsl:text><xsl:value-of select="$spécialité" /><xsl:text>}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\vspace{1.5cm}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>Soutenue publiquement le </xsl:text><xsl:value-of select="$date-soutenance" /><xsl:text>, par~:\\
</xsl:text> + <xsl:text>\fontsize{14pt}{16pt}\selectfont
</xsl:text> + <xsl:text>\textbf{</xsl:text><xsl:value-of select="$auteur" /><xsl:text>}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\vspace{1.5cm}
</xsl:text> <!-- Adapter à la longueur du titre --> + <xsl:text>
</xsl:text> + <xsl:text>\rule[20pt]{\textwidth}{0.5pt}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\fontsize{25pt}{22pt}\selectfont
</xsl:text> + <xsl:text>\textbf{</xsl:text><xsl:value-of select="$titre" /><xsl:text>}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\rule{\textwidth}{0.5pt}
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\vspace{2cm}
</xsl:text> <!-- Adapter à la longueur du titre --> + <xsl:text>\end{center}
</xsl:text> <!-- Adapter à la longueur du titre --> + <xsl:text>
</xsl:text> + <xsl:text>\fontsize{12pt}{14pt}\selectfont
</xsl:text> + <xsl:text>Devant le jury composé de~:
</xsl:text> + <xsl:text>\bigskip
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:text>\fontsize{11pt}{13pt}\selectfont
</xsl:text> + <xsl:text>
</xsl:text> + <xsl:apply-templates select="/html:html/html:head/m:page-de-garde/m:jury" /> + <xsl:text>
</xsl:text> + <xsl:text>\end{document}
</xsl:text> + </xsl:template> + + <xsl:template match="m:jury"> + <xsl:text>\begin{itemize}
</xsl:text> + <xsl:apply-templates /> + <xsl:text>\end{itemize}
</xsl:text> + </xsl:template> + + <xsl:template match="m:membre"> + <xsl:variable name="name"> + <xsl:apply-templates /> + </xsl:variable> + <xsl:variable name="grade"> + <xsl:call-template name="escape-latex"> + <xsl:with-param name="str" select="@grade" /> + </xsl:call-template> + </xsl:variable> + <xsl:variable name="affiliation"> + <xsl:call-template name="escape-latex"> + <xsl:with-param name="str" select="@affiliation" /> + </xsl:call-template> + </xsl:variable> + <xsl:variable name="rôle"> + <xsl:call-template name="escape-latex"> + <xsl:with-param name="str" select="@rôle" /> + </xsl:call-template> + </xsl:variable> + <xsl:text>\item </xsl:text> + <xsl:value-of select="normalize-space($name)" /> + <xsl:text>, </xsl:text> + <xsl:value-of select="$grade" /> + <xsl:text>, </xsl:text> + <xsl:value-of select="$affiliation" /> + <xsl:text>, </xsl:text> + <xsl:value-of select="$rôle" /> + <xsl:text>
</xsl:text> + </xsl:template> +</xsl:stylesheet> |
