Very simply, if you choose any number other than 1, you can simply scale it away again. Consider Now, divide both sides of the equation by , and we get Which means that we can define and , and we have And because the goal is to minimise (in order to maximise the size of the margin, ), it doesn't matter if we scale by some constant such as first - and so, we can use in place of , and the choice of is irrelevant (aside from needing to be a positive real number).

Since it's irrelevant, might as well make it the simplest possible positive real number, 1.

As for why it "sets the scale" of the problem, think of it this way: changing would change the scaling of (that is, choosing would make twice as big, for example). And so, just as changing changes the scale, so too does setting set the scale - it keeps it fixed, rather than having it vary from instance to instance.

This is an excellent question and one I struggled with as well.

Firstly, the margin is not fixed. As your diagram shows, the margin $m = \frac{2}{\lVert w \rVert}$, which is a function of the 2-norm of the $w$ parameter, nothing else. So the margin is maximized by minimizing the norm of $w$.

But let's back up to see why.

We have some data represented as vectors $x_i \in \mathbb{R}^n$ and each $x_i$ is associated with a binary label $y_i \in \{-1,1\}$, for $i \in \mathbb{N}$. We could have made the labels anything, but choosing -1 and 1 is mathematically convenient.

An (affine) hyperplane is the generalization of a line in n-dimensional space defined as the set of points $x$ such that $w^Tx + b = 0$, where $w, x \in \mathbb{R}^n$ and $w^Tx$ is the dot (inner) product between these vectors. The choice of $w$ will change the orientation of the hyperplane and the choice of $b$ will determine its offset from the origin.

We want to find a hyperplane (i.e. choice of $w, b$) that separates the data $x_i$ according to their class labels. We assume our data can be perfectly separated by a line (or hyperplane), i.e. it is linearly separable. So we want a hyperplane such that when $y_i = -1$ then $w^Tx_i + b \le 0$ and when $y_i = 1$ then $w^Tx_i + b \ge 0$. There's actually a fairly straightforward algorithm called the perceptron algorithm that can find a hyperplane meeting those constraints.

But there are an infinite number of hyperplanes (i.e. choices of $w, b$) that can satisfy the constraints of separating the data classes, so in order for our hyperplane to work well in classifying future data, we want it to optimally separate the data classes such that it is not biased toward one class or another and is situated perfectly between them with maximal space on either side (maximal margins).

The easier way to set this up is that what we really want is to define two parallel hyperplanes, one just on the inside boundary of class $y_i = -1$ and the other just on the inside boundary of the class $y_i = 1$, then the actual decision boundary will be the parallel hyperplane exactly in the middle of these.

In other words, if we have our decision boundary hyperplane as $w^Tx + b = 0$, then we want to find a $\delta > 0$ such that we can define two parallel hyperplanes on either side: $w^Tx + b = 0 \pm \delta$. We'd like to maximize $\delta$ so that the distance between these two boundary hyperplanes is maximal, that will give us maximal separation between the classes.

But if we keep $\delta$ a variable, then changing the norm of $w$, changing $b$ or changing $\delta$ will change the margin between the two hyperplanes. We really only want to optimize $w, b$. Moreover, if we change $\delta$ by any scalar amount, then we can just scale $w, b$ an opposite amount, so we can fix $\delta$ to anything we want and still be able to adjust the margin by modifying $w, b$.

This is where the $\pm 1$ comes from, it is from arbitrarily fixing $\delta = \pm 1$ because it is a convenient choice.

So we define our two parallel separating hyperplanes as: $$ w^Tx + b = \pm 1$$

Then the margin is the distance between these two parallel hyperplanes. The displacement from the origin to a hyperplane is $\frac{b}{\Vert w \Vert}$, and we can use this fact to compute the distance between our hyperplanes. The distance from the origin to the first hyperplane is $\frac{b+1}{\Vert w \Vert}$ and to the second hyperplane is $\frac{b-1}{\Vert w \Vert}$, so the distance between them is (aka margin $m$): $$m = \frac{b+1}{\Vert w \Vert} - \frac{b-1}{\Vert w \Vert}$$ $$m = \frac{2}{\Vert w \Vert} $$

So the optimal hyperplane will be found by maximizing $m$, i.e. $$ \underset{w}{max}\frac{2}{\Vert w \Vert} = \underset{w}{min}\frac{1}{2}{\Vert w \Vert}$$ subject to the constraint $y_i(w^Tx_i + b) \ge 1$.

Now, if we had arbitrarily chosen $\delta = \pi$ instead of 1, the margin would be $\frac{2\pi}{\Vert w \Vert}$, but this is just a change in scaling and the optimization problem is identical in form.

SVM-based classifier contains Support Vectors

to read it from svmStruct a bit more easily, use svmtrain call with "AUTOSCALE", false:

svmStruct.SupportVectors

svmStruct = 

          SupportVectors: [3x2 double]
                   Alpha: [3x1 double]
                    Bias: -23.1428
          KernelFunction: @linear_kernel
      KernelFunctionArgs: {}
              GroupNames: [150x1 logical]
    SupportVectorIndices: [3x1 double]
               ScaleData: []
           FigureHandles: {[170.0012] [171.0052 172.0018] [225.0018]}


ans =

    5.5000 3.5000
    4.5000 2.3000
    4.9000 2.5000

or

>> data( svmStruct.SupportVectorIndices,: )

ans =

    5.5000 3.5000
    4.5000 2.3000
    4.9000 2.5000

If you use the default 'autoscale' option, then you will need to unwind the scaling using something rather ugly like this:

 (    data( svmStruct.SupportVectorIndices( 1 ),: )
    + svmStruct.ScaleData.shift
  ).* svmStruct.ScaleData.scaleFactor

( >>> https://www.mathworks.com/matlabcentral/newsreader/view_thread/249055 )

For construction of a separating Hyperplane from SVM-classifier internal data, you may be interested in >>> http://scikit-learn.org/stable/auto_examples/svm/plot_separating_hyperplane.html

Parameters for to plot the maximum margin separating hyperplane within a two-class separable dataset using a Support Vector Machines classifier with linear kernel