Это 24-й день моего участия в августовском испытании обновлений. Узнайте подробности события:Испытание августовского обновления

Заметки о машинном обучении Эндрю Нг - (6) Классификация

Intro of Classification

Classification problems are something like giving a patient with a tumor, we have to predict whether the tumor is malignant or benign. It's expected to output discrete values.

The classification problem is just like the regression problem, except that the values we want to predict take on only a small number of discrete values. For now, we will focus on the binary classification problem in which y can take only two values, 0 and 1.

For instance, if we are trying to build a spam classifier for email, then $x^{(i)}$ may be some features of a piece of email, and $y$ may be 1 if it is a piece of spam mail, and 0 otherwise. Hence, $y \in \{0,1\}$. 0 is also called the negative class, and 1 the positive class, and they are sometimes also denoted by the symbols - and +. Given $x^{(i)}$, the corresponding $y^{(i)}$ is also called the label for the training example.

To attempt classification, one method is to use linear refression and map all predictions greater than 0.5 as a 1 and all less than 0.5 as a 0. However, this method doesn't work because classification is not actually a linear function. So what we actually do to solve classification problems is an algorithm named logistic regression. Note that even be called regression, it is actually to do classification.

Logistic Regression

Hypothesis Representation

We could approach the classification problem ignoring the fact that y is discrete-valued, and use our old linear regression algorithm to try to predict y given x. However it is easy to construct examples where this method performs very poorly.

Intuitively, it also doesn't make sense for $h_\theta(x)$ to take values larger than 1 or smaller then 0 when we know that $y\in\{0,1\}$. To fix this, let's change our hypotheses $h_\theta(x)$ to satisfy $0 \le h_\theta(x) \le 1$. This accomplished by plugging $\theta^Tx$ into the Logistic Function.

The the Simoid Function, also called the Logistic Function is this:

It looks like the following image:

Our new form uses the Simoid Function:

The logistic function $g(z)$ maps any real numbers to the $(0,1)$ interval, making it useful for transforming a arbitrary-valued function into a function better suited for classfication.

We can also simply write $h_\theta(x)$ like this:

$h_\theta(x)$ will output the probalility that our output is 1. For example, $h_\theta(x)=0.7$ gives us a probability of $70\%$ that our output is $1$ (then the probability that it is 0 is 30%):

Decision Boundary

In order to get our discrete 0 or 1 classification, we can translate the output of the hyporithesis function as follows:

The way our logistic function $g$ behaves is that when its input is $\ge 0$, its output is $\ge 0.5$:

In fact, we know that:

So if our input to $g$ is $\theta^TX$, then that means:

From these statements we can now say:

The decision boundary is the line that separates the area where $y=0$ and where $y=1$. It is created by our hypothesis function.

Example:

In this case, $y=1$ if $5+(-1)x_1+0x_2 \ge 0$ , i.e. $x_1 \le 5$. Our boundary is a straight vertical line placed on the graph where $x_1=5$, and everything to the left of that denotes $y=1$, while everything to the right denotes $y=0$:

Another example:

Non-linear decision boundaries:

The input to the sigmoid function g(z) (e.g. $\theta^TX$) doesn't need to be linear, and could be a function that describes a circle (e.g. $z=\theta_0+\theta_1x_1^2+\theta_2x_2^2$) or any shape to fit our data.

Example:

Logistic Regression Model

In this part, we will implement the logistic regression model.

Cost Function

If we use the same cost function that we use for linear regression ($J(\theta)=\frac{1}{m}\sum_{i=1}^m\frac{1}{2}(h_\theta(x^{(i)})-y^{(i)})^2$) for logistic regression, it will be non-convex (that looks wavy), which is causing many local optima and hard to find the global minimum.

So, what we actually need is our new Logistic Regression Cost Function, which guarantees that $J(\theta)$ is convex for logistic regression.

“$J(\theta)$-$h_\theta(x)$"сюжеты такие:

Let's take a look at the $Cost(h_\theta(x),y)$ :

If our correct answer 'y' is 0, then the cost function will be 0 if our hypothesis function also outputs 0. If our hypothesis approaches 1, then the cost function will approach infinity.

If our correct answer 'y' is 1, then the cost function will be 0 if our hypothesis function outputs 1. If our hypothesis approaches 0, then the cost function will approach infinity.

Simplified Cost Function

We can simplify the $Cost$ function by compressing the two conditional cases into one case:

In this definition, when $y=0$, the term $-(1-y) \cdot log(1-h_\theta(x))$ will be $0$; when $y=0$, the term $-y \cdot log(h_\theta(x))$ will be $0$. Obviously, this is equal to the previous one but more easy to implement.

Now, we can fully write out our entire cost function as follow:

And a vectorized implementation is:

Gradient Descent

The general form of gradient descent is:

Work out the derivative part using calculus to get:

Actually, this algorithm is identical to the one we used in linear regression. And notice that we still have to simultaneously update all values in theta.

Vectorized implementation:

Advanced Optimization

There are many more sophisticated, faster ways to optimize $\theta$ that can be used instead of gradient descent, such as "Conjugate gradient", "BFGS" and "L-BFGS".

We are not suggest to write these more sophisticated algorithms ourself but use the libraries instead, as they're already tested and highly optimized. Octave provides them.

We can use octave's fminunc() optimization algorithm to do that.

To use this advanced optimization, we first need to provide a function that evaluates the following two functions for a given inpuit value $\theta$:

We can write a single function that retunrs both of these:

function [jVal, gradient] = costFunction(theta)
	jVal = <code to compute J(theta)>
	gradient = <code to compute derivative of J(theta)>
end

Then we are going to set a optimset and a initial theta as well, then send them to fminunc():

options = optimset('GradObj', 'on', 'MaxIter', 100);
initialTheta = zeros(2, 1);

[optTheta, functionVal, exitFlag] = fminunc(@costFunction, initialTheta, options);

Multiclass Classification

Now we will approach the classification of data when we have more than two categories. Instead of $y=\{0,1\}$ we will expand our definition so that $y=\{0,1...n\}$.

Since $y=\{0,1...n\}$, we divide our problem into $n+1$ ($+1$ because the index starts at $0$) binary classification problems; in each one, we predict the probability that '$y$' is a member of one of our classes.

We are basically choosing one class and then lumping all the others into a single second class. We do this repeatedly, applying binary logistic regression to each case, and then use the hypothesis that returned the highest value as our prediction.

The following image shows how one could classify 3 classes:

To summarize:

Train a logistic regression classifier $h_\theta(x)$для каждого класса предсказать вероятность того, что  $y=i$  Чтобы сделать прогноз на новый$x$, выберите класс, который максимизирует$h_\theta(x)$.