Written MATLAB code

Author: lamferzon

Presentation/Presentation.pdf

@@ -3,6 +3,9 @@
 \usecolortheme{beaver}
 \usepackage{amsmath}
 \usepackage{ragged2e}
+\usepackage{listings}
+\usepackage{fancyvrb}
+\usepackage{adjustbox}
 \justifying 
 
 \title[Implementation of the PLS algorithm]{Implementation in MATLAB of the Partial Least Squares algorithm for classification}

Presentation/Presentation.tex

@@ -0,0 +1,11 @@
+\begin{Verbatim}[tabsize=4, commandchars=\\\{\}, frame=bottomline]
+	\textcolor{green}{% calculation of W, P, T and B2}
+	W(:, j) = w;
+	P(:, j) = p;
+	T(:, j) = t;
+	B2 = W*(P'*W)^-1*(T'*T)^-1*T'*Y;
+\textcolor{blue}{end}
+Y_hat = X*B2; \textcolor{green}{% computation of predictions}
+	\end{Verbatim}
+For each row of \verb|Y_hat| the fault class is chosen by assigning $1$ to the column whose value si greater than that of the others, $0$ otherwise. Moreover, to increase the performances of PLS it is necessary \textbf{normalize} both $X$ and $Y$ before running the algorithm.
+

Presentation/Presentation.vrb

@@ -1,4 +1,4 @@
-\section{Fault detection and diagnosis on steel plates}
+\section{Fault detection and isolation on steel plates}
 
 \begin{frame}
 	TO DO

Presentation/Sections/Case study.tex

@@ -14,13 +14,18 @@ \section{Introduction}
 \begin{frame}
 	\frametitle{Popular application of PLS}
 	This technique is often used in \textbf{fault detection} and \textbf{isolation}. With PLS is possible to treat both regression and classification problems. The matrix $X$ always contains the process variables (e.g. diameter and thickness of a gasket), while the matrix $Y$ only (quantitative) quality variables (e.g. its mechanical seal) in the regression case, whereas in pattern classification the predicted variables are dummy variables ($1$ or $0$) such as:
-	\begin{equation}
+	\begin{equation*}
 		Y = 
+		\begin{bmatrix}
+			\boldsymbol{y}_1 & \boldsymbol{y}_2 & \boldsymbol{y}_3\\
+		\end{bmatrix}
+		=
 		\begin{bmatrix}
 			1 & \dots & 1 & 0 & \dots & 0 & 0 & \dots & 0\\
 			0 & \dots & 0 & 1 & \dots & 1 & 0 & \dots & 0\\
 			0 & \dots & 0 & 0 & \dots & 0 & 1 & \dots & 1\\
-		\end{bmatrix}^\top
-	\end{equation}
-	where each column of $Y$ corresponds to a fault class. The first $n_j$ elements of column $j$ are filled with a $1$, which indicates that the first $n_j$ rows of $X$ are data from fault $j$. In this case PLS is called \textbf{discriminant}.
+		\end{bmatrix}^\top 
+		p = 3
+	\end{equation*}
+	where each column of $Y$ corresponds to a \textit{fault class}. The first $n_j$ elements of column $j$ are filled with a $1$, which indicates that the first $n_j$ rows of $X$ are data from fault $j$. In classification case PLS is named \textbf{discriminant}.
 \end{frame}

Presentation/Sections/Introduction.tex

@@ -1,5 +1,67 @@
 \section{Description of the PLS  algorithm}
 
-\begin{frame}
-	TO DO
-\end{frame}
+\begin{frame}[fragile]
+	\frametitle{NIPALS algorithm}
+	The most popular algorithm used in PLS to compute the model parameters is known as \textbf{non-iterative partial least squares} (\textbf{NIPALS}). There are two versions of this technique:
+	\begin{itemize}
+		\item \textbf{PLS1}: each of the \textit{p} predicted variables in modeled separately, resulting in one model for each class;
+		\item \textbf{PLS2}: all predicted variables are modeled simultaneously.
+	\end{itemize}
+	The first algorithm is more accurate than the other, however it requires more computational time than PLS2 to find the $\alpha$ eigenvectors into which project the \textit{m} covariates. 
+\end{frame}
+
+\begin{frame}[fragile]
+	\frametitle{MATLAB code}
+	The following MATLAB code implements the PLS2 algorithm:
+	\begin{Verbatim}[tabsize=4, commandchars=\\\{\}, frame=topline]
+E = X; \textcolor{green}{% residual matrix for X}
+F = Y; \textcolor{green}{% residual matrix for Y}
+[~, idx] = max(sum(Y.*Y));
+\textcolor{green}{% search of the j-th eigenvector}
+\textcolor{blue}{for} j = 1:alpha
+	u = F(:, idx);
+	tOld = 0;
+	\textcolor{blue}{for} i = 1:maxIter
+		w = (E'*u)/norm(E'*u); \textcolor{green}{% support vector}
+		t = E*w; \textcolor{green}{% j-th column of the score matrix for X}
+		q = (F'*t)/norm(F'*t); \textcolor{green}{% j-th column of the...}
+			\textcolor{green}{% loading matrix for Y}
+		u = F*q; \textcolor{green}{% j-th column of the score matrix for Y}
+	\end{Verbatim}
+\end{frame}
+
+\begin{frame}[fragile]
+	\begin{Verbatim}[tabsize=4, commandchars=\\\{\}]
+		\textcolor{blue}{if} abs(tOld - t) < exitTol
+			\textcolor{blue}{break};
+		\textcolor{blue}{else}
+			tOld = t;
+		\textcolor{blue}{end}
+	\textcolor{blue}{end}
+	p = (E'*t)/(t'*t); \textcolor{green}{% j-th column of the...}
+		\textcolor{green}{% loading matrix of X}
+	\textcolor{green}{% scaling}
+	t = t*norm(p);
+	w = w*norm(p);
+	p = p/norm(p);
+	\textcolor{green}{% calculation of b and the error matrices}
+	b = (u'*t)/(t'*t); \textcolor{green}{% j-th column of the...}
+	    \textcolor{green}{% coefficient regression matrix}
+	E = E - t*p';
+	F = F - b*t*q';
+	\end{Verbatim}
+\end{frame}
+
+\begin{frame}[fragile]
+	\begin{Verbatim}[tabsize=4, commandchars=\\\{\}, frame=bottomline]
+	\textcolor{green}{% calculation of W, P, T and B2}
+	W(:, j) = w;
+	P(:, j) = p;
+	T(:, j) = t;
+	B2 = W*(P'*W)^-1*(T'*T)^-1*T'*Y;
+\textcolor{blue}{end}
+Y_hat = X*B2; \textcolor{green}{% computation of predictions}
+	\end{Verbatim}
+For each row of \verb|Y_hat| the fault class is chosen by assigning $1$ to the column whose value si greater than that of the others, $0$ otherwise. Moreover, to increase the performances of PLS it is necessary \textbf{normalize} both $X$ and $Y$ before running the algorithm.
+
+\end{frame}