{"id":4797,"date":"2020-02-15T11:30:32","date_gmt":"2020-02-15T11:30:32","guid":{"rendered":"https:\/\/prwatech.in\/blog\/?p=4797"},"modified":"2026-10-15T16:05:21","modified_gmt":"2026-10-15T16:05:21","slug":"support-vector-machine-tutorial-for-beginners","status":"publish","type":"post","link":"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/","title":{"rendered":"Support Vector Machine Tutorial"},"content":{"rendered":"

Support Vector Machine Tutorial for Beginners<\/b><\/strong><\/h1>\n

Imagine two groups of houses on opposite sides of a river, and you need to draw a fence that separates them. You could draw it anywhere in the gap, but some fences are better than others. A fence that hugs one group is risky, because a new house built a little off the pattern ends up on the wrong side. The safest fence runs down the middle of the widest empty space. That is the whole idea behind the support vector machine.<\/p>\n

A support vector machine, or SVM, is a supervised learning algorithm used mainly for classification. It looks for the boundary that separates classes with the largest possible gap on both sides. That gap is called the margin, and the data points that touch it are called support vectors. A wide margin gives a model that tends to cope well with new data, which is why SVMs became one of the most trusted algorithms for problems with small and medium sized datasets and many features, such as text and gene data.<\/p>\n

This tutorial starts from the plain picture and builds up. You will learn what a hyperplane is, how the margin and the support vectors work, and how SVM chooses between several possible boundaries. Then comes the part that makes SVM powerful: the kernel trick, which lets it separate data that no straight line can divide. We cover the two settings that matter most, C and gamma, and finish with a complete Python program using scikit learn that was run and checked, plus common mistakes and a short FAQ.<\/p>\n

What is a Support Vector Machine?<\/b><\/strong><\/h2>\n

In a two class problem, SVM finds a boundary between the classes. With two features, that boundary is a line. With three features it is a flat plane. With more features it is called a hyperplane<\/b><\/strong>, which is simply the same idea in higher dimensions. A new point is classified by which side of the hyperplane it falls on.<\/p>\n

Many hyperplanes can separate the same data. SVM picks the one with the maximum margin<\/b><\/strong>, meaning the largest distance to the nearest point of each class.<\/p>\n

What are Support Vectors?<\/b><\/strong><\/h2>\n

Support vectors are the training points closest to the boundary. They sit right on the edge of the margin, and they alone decide where the hyperplane goes. If you removed every other point, the boundary would not move. If you moved a support vector, the boundary would shift.<\/p>\n

This is a useful property. SVM does not need to remember all the data, only the handful of points that matter. In the program later in this tutorial, a model trained on 210 points needed only 67 support vectors.<\/p>\n

\"Support<\/p>\n

How Does SVM Work?<\/b><\/strong><\/h2>\n

The process has a simple logic, which we can follow in four steps.<\/p>\n

    \n
  1. <\/b>Draw candidate boundaries. <\/b><\/strong>Many lines could split the classes.<\/li>\n
  2. <\/b>Measure the margin of each. <\/b><\/strong>The margin is the distance from the boundary to the nearest point on either side.<\/li>\n
  3. <\/b>Pick the widest. <\/b><\/strong>The boundary with the largest margin is chosen.<\/li>\n
  4. <\/b>Classify new points. <\/b><\/strong>Each new point is labelled by the side of the boundary it lands on.<\/li>\n<\/ol>\n

    How to Choose the Right Hyperplane?<\/b><\/strong><\/h2>\n

    When the choice is not obvious, these five situations show how SVM reasons. Each one has a picture on the original page, which stays in place below.<\/p>\n

    Criterion 1: Pick the Hyperplane That Separates the Classes Better<\/b><\/strong><\/h3>\n

    If several lines are candidates, the one that splits the two classes more cleanly is the better choice. A line that leaves points of both classes on one side is clearly worse than a line that keeps each class on its own side.<\/p>\n

    \"Support<\/p>\n

    Criterion 2: Maximise the Distance to the Nearest Points<\/b><\/strong><\/h3>\n

    When more than one line separates the classes correctly, choose the one with the largest distance to the nearest point of each class. This distance is the margin. A larger margin means more room for error, so the boundary is more likely to hold up on new data.<\/p>\n

    \"Support<\/p>\n

    Criterion 3: Classify Correctly Before You Maximise the Margin<\/b><\/strong><\/h3>\n

    A wider margin is not worth it if it misclassifies points. SVM puts correct classification first. It looks for the widest margin only among boundaries that already separate the data well.<\/p>\n

    \"Support<\/p>\n

    Criterion 4: Ignore Outliers When the Data Has Them<\/b><\/strong><\/h3>\n

    Sometimes a single point sits deep inside the other class. A strict boundary would twist itself to catch that point and end up with a tiny margin. SVM can treat such a point as an outlier and ignore it, which keeps the boundary simple and the margin wide. How strict it is about this is controlled by the setting called C, covered below.<\/p>\n

    \"Support<\/p>\n

    Criterion 5: Add a Dimension When No Straight Line Works<\/b><\/strong><\/h3>\n

    Some data cannot be split by any straight line, for example one class forming a ring around the other. In that case SVM adds a new feature to lift the points into a higher dimension, where a flat boundary can separate them. This is the idea of the kernel trick, explained next.<\/p>\n

    \"Support<\/p>\n

    The Kernel Trick in Plain Words<\/b><\/strong><\/h2>\n

    Take points where one class sits near the center and the other forms a ring around it. No line can separate them on a flat page. Now add a third value for each point, z = x squared plus y squared, which is the squared distance from the center. The inner points get small z values and the outer points get large ones. In three dimensions, a flat sheet at the right height splits them cleanly.<\/p>\n

    z = x^2+y^2<\/p>\n

    \"S<\/p>\n

    Computing new features for every point can be expensive. The kernel trick<\/b><\/strong>\u00a0gets the same result without ever building the new features. A kernel function measures how similar two points are as if they were in the higher dimension, and the algorithm needs only that similarity. This is why SVM can work with very complex boundaries at a reasonable cost.<\/p>\n

    Tuning Parameters of SVM<\/b><\/strong><\/h2>\n

    Kernel<\/b><\/strong><\/h3>\n

    The kernel decides the shape of the boundary. These are the four built in options in scikit learn.<\/p>\n

    \n\n\n\n\n\n\n\n\n
    SVM kernels compared<\/caption>\n
    Kernel<\/th>\nWhat it does<\/th>\nUse it when<\/th>\n<\/tr>\n<\/thead>\n
    linear<\/th>\nA straight line or flat plane<\/td>\nData is roughly separable by a line, or you have many features, as in text<\/td>\n<\/tr>\n
    poly<\/th>\nA curved boundary of a chosen degree. The formula is gamma times the dot product of the points, plus a constant r, all raised to the power d<\/td>\nYou expect interactions between features. Slower, and the degree needs tuning<\/td>\n<\/tr>\n
    rbf<\/th>\nA smooth, flexible curve. Similarity falls with distance, as exp of minus gamma times the squared distance between points<\/td>\nThe safe default when you do not know the shape of the data<\/td>\n<\/tr>\n
    sigmoid<\/th>\nBased on the tanh function, like a small neural network unit<\/td>\nRarely. It can behave poorly, so try rbf first<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n

     <\/p>\n

    In practice, start with linear to get a baseline, then try rbf. Choose between them on validation data, not by guess.<\/p>\n

    Regularization: The C Parameter<\/b><\/strong><\/h3>\n

    C controls how much SVM is punished for misclassifying training points. It is the balance between a wide margin and a perfect fit.<\/p>\n

      \n
    • <\/b>Low C<\/b><\/strong>accepts a few mistakes in return for a wider, smoother boundary.<\/li>\n
    • <\/b>High C<\/b><\/strong>tries hard to classify every training point correctly, which gives a narrower margin and a twisted boundary that can overfit.<\/li>\n<\/ul>\n

      The default in scikit learn is 1. Think of C as how strictly the model is graded on its training data.<\/p>\n

      \"S<\/p>\n

      \"S<\/p>\n

      Gamma<\/b><\/strong><\/h3>\n

      Gamma applies to the rbf, poly and sigmoid kernels. It sets how far the influence of a single training point reaches.<\/p>\n

        \n
      • <\/b>Low gamma<\/b><\/strong>means each point has a far reaching influence, so the boundary is smooth and simple.<\/li>\n
      • <\/b>High gamma<\/b><\/strong>means each point only affects its close neighbours, so the boundary wraps tightly around individual points and can overfit.<\/li>\n<\/ul>\n

        Margin<\/b><\/strong><\/h3>\n

        The margin is the output of those settings working together. A good margin leaves a clear gap between the classes on both sides of the boundary. A bad one is too narrow, close to one class, or has points inside it. Always judge it with a held out test set, not by how the training plot looks.<\/p>\n

        \"S<\/p>\n

        \"S<\/p>\n

        SVM in Python With scikit learn<\/b><\/strong><\/h2>\n

        Here is a full program using two datasets. The first part compares the three main kernels on the Iris flower dataset, which has 150 flowers in 3 species. The second part uses a curved, noisy two class dataset to show what changing gamma and C actually does. The last line counts the support vectors.<\/p>\n

        Notice that the first part wraps the SVM in a pipeline with a scaler. This matters, and the reason is explained in the next section.<\/p>\n

        from sklearn.datasets import load_iris, make_moons<\/p>\n

        from sklearn.model_selection import train_test_split<\/p>\n

        from sklearn.pipeline import make_pipeline<\/p>\n

        from sklearn.preprocessing import StandardScaler<\/p>\n

        from sklearn.svm import SVC<\/p>\n

         <\/p>\n

        # Part 1: three kernels on the Iris dataset<\/p>\n

        X, y = load_iris(return_X_y=True)<\/p>\n

        X_train, X_test, y_train, y_test = train_test_split(<\/p>\n

        X, y, test_size=0.3, random_state=0, stratify=y<\/p>\n

        )<\/p>\n

        for kernel in [“linear”, “poly”, “rbf”]:<\/p>\n

        model = make_pipeline(StandardScaler(), SVC(kernel=kernel))<\/p>\n

        model.fit(X_train, y_train)<\/p>\n

        print(kernel, “kernel test accuracy:”, round(model.score(X_test, y_test), 3))<\/p>\n

         <\/p>\n

        # Part 2: how gamma and C change the result on curved data<\/p>\n

        Xm, ym = make_moons(n_samples=300, noise=0.3, random_state=0)<\/p>\n

        Xm_train, Xm_test, ym_train, ym_test = train_test_split(<\/p>\n

        Xm, ym, test_size=0.3, random_state=0, stratify=ym<\/p>\n

        )<\/p>\n

        print(“gamma \u00a0train \u00a0test”)<\/p>\n

        for gamma in [0.01, 1, 100]:<\/p>\n

        m = SVC(kernel=”rbf”, gamma=gamma, C=1).fit(Xm_train, ym_train)<\/p>\n

        print(gamma, round(m.score(Xm_train, ym_train), 3), round(m.score(Xm_test, ym_test), 3))<\/p>\n

        print(“C \u00a0\u00a0\u00a0\u00a0\u00a0train \u00a0test”)<\/p>\n

        for C in [0.01, 1, 1000]:<\/p>\n

        m = SVC(kernel=”rbf”, gamma=1, C=C).fit(Xm_train, ym_train)<\/p>\n

        print(C, round(m.score(Xm_train, ym_train), 3), round(m.score(Xm_test, ym_test), 3))<\/p>\n

         <\/p>\n

        # Part 3: support vectors<\/p>\n

        final = SVC(kernel=”rbf”, gamma=1, C=1).fit(Xm_train, ym_train)<\/p>\n

        print(“Support vectors per class:”, final.n_support_, “of”, len(Xm_train), “training points”)<\/p>\n

        Part 1: Three Kernels on Iris<\/b><\/strong><\/h3>\n

        When I ran it, the first part printed:<\/p>\n

        linear kernel test accuracy: 1.0<\/p>\n

        poly kernel test accuracy: 0.867<\/p>\n

        rbf kernel test accuracy: 0.978<\/p>\n

        The test set has 45 flowers. The linear kernel classified all of them correctly. The rbf kernel missed one flower. The polynomial kernel missed six, because a curved boundary of this type is more than the Iris data needs. The simple kernel won, which is common on data that is already almost separable.<\/p>\n

        \"S<\/p>\n

        \"S<\/p>\n

        Let\u2019s apply rbf kernel:<\/h3>\n

        svc = svm.SVC(kernel=’rbf’, C=1,gamma=’auto’).fit(X, y)<\/p>\n

        Output:<\/strong><\/h3>\n

        \"S<\/p>\n

        Part 2: The Effect of Gamma and C<\/b><\/strong><\/h3>\n

        The second part printed:<\/p>\n

        gamma \u00a0train \u00a0test<\/p>\n

        0.01 0.843 0.756<\/p>\n

        1 0.933 0.922<\/p>\n

        100 0.986 0.922<\/p>\n

        C \u00a0\u00a0\u00a0\u00a0\u00a0train \u00a0test<\/p>\n

        0.01 0.857 0.767<\/p>\n

        1 0.933 0.922<\/p>\n

        1000 0.948 0.933<\/p>\n

        \n\n\n\n\n\n\n\n\n\n\n
        SVM results for different gamma and C settings<\/caption>\n
        Setting<\/th>\nTrain accuracy<\/th>\nTest accuracy<\/th>\nWhat it shows<\/th>\n<\/tr>\n<\/thead>\n
        gamma 0.01<\/th>\n0.843<\/td>\n0.756<\/td>\nToo smooth, underfits<\/td>\n<\/tr>\n
        gamma 1<\/th>\n0.933<\/td>\n0.922<\/td>\nA good balance<\/td>\n<\/tr>\n
        gamma 100<\/th>\n0.986<\/td>\n0.922<\/td>\nTrain rises, test does not<\/td>\n<\/tr>\n
        C 0.01<\/th>\n0.857<\/td>\n0.767<\/td>\nToo forgiving, underfits<\/td>\n<\/tr>\n
        C 1<\/th>\n0.933<\/td>\n0.922<\/td>\nA good balance<\/td>\n<\/tr>\n
        C 1000<\/th>\n0.948<\/td>\n0.933<\/td>\nA small gain on test<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n

         <\/p>\n

          \n
        • <\/b>Both extremes at the low end underfit. <\/b><\/strong>Test accuracy drops to about 0.76.<\/li>\n
        • <\/b>Gamma 100 shows the start of overfitting. <\/b><\/strong>Training accuracy climbs to 0.986, but test accuracy stays at 0.922, so the extra fit bought nothing.<\/li>\n
        • <\/b>Be careful with small gaps. <\/b><\/strong>The test set has only 90 points, and one point is worth about 1.1 points of accuracy. The C 1000 result of 0.933 is one point better than C 1, which is within the noise, not proof that a high C is better.<\/li>\n<\/ul>\n

          \"S<\/p>\n

           <\/p>\n

          \"S<\/p>\n

          Part 3: Support Vectors<\/b><\/strong><\/h3>\n

          The last line printed:<\/p>\n

          Support vectors per class: [32 35] of 210 training points<\/p>\n

          Only 67 of the 210 training points define the boundary. You can read them from the model with the support_vectors_ attribute, and the count per class with n_support_.<\/p>\n

          Practical Advice Before You Use SVM<\/b><\/strong><\/h2>\n

          Always Scale Your Data<\/b><\/strong><\/h3>\n

          SVM measures distances, so a feature with large numbers, such as salary, will swamp one with small numbers, such as age. SVMs are not scale invariant. Use StandardScaler inside a pipeline, as the program does, so the scaler is fitted only on training data.<\/p>\n

          Tune C and Gamma Together<\/b><\/strong><\/h3>\n

          Use GridSearchCV and try values spaced by powers of ten, such as 0.01, 0.1, 1, 10 and 100. The best C and gamma depend on each other, so search them together, not one at a time.<\/p>\n

          Be Careful With Probabilities<\/b><\/strong><\/h3>\n

          SVC does not give probabilities by default. Setting probability=True adds an extra cross validation step, which makes training much slower. If you only need a ranking or a confidence score, use decision_function instead.<\/p>\n

          Watch the Size of Your Data<\/b><\/strong><\/h3>\n

          Training time grows quickly with the number of rows, somewhere between the square and the cube. It is comfortable up to tens of thousands of rows. For much larger data, use LinearSVC, which scales almost in a straight line.<\/p>\n

          Handle Imbalanced Classes<\/b><\/strong><\/h3>\n

          If one class is rare, set class_weight to balanced, so mistakes on the rare class cost more.<\/p>\n

          Strengths and Limitations of SVM<\/b><\/strong><\/h2>\n

          Strengths<\/b><\/strong><\/h3>\n
            \n
          • Works well when there are many features, even more than rows.<\/li>\n
          • Effective on small and medium datasets.<\/li>\n
          • Memory efficient, because only support vectors are stored.<\/li>\n
          • Flexible, because different kernels fit different shapes of data.<\/li>\n<\/ul>\n

            Limitations<\/b><\/strong><\/h3>\n
              \n
            • Slow to train on very large datasets.<\/li>\n
            • Sensitive to feature scaling and needs tuning of C and gamma.<\/li>\n
            • Does not give probabilities directly.<\/li>\n
            • Hard to interpret with non linear kernels.<\/li>\n
            • Can struggle when classes overlap heavily and the data is noisy.<\/li>\n<\/ul>\n

              Where SVM is Used?<\/b><\/strong><\/h2>\n
                \n
              • <\/b>Text classification. <\/b><\/strong>Spam filtering and topic labelling, where each word is a feature.<\/li>\n
              • <\/b>Image classification. <\/b><\/strong>Handwritten digit and face recognition on smaller datasets.<\/li>\n
              • <\/b><\/b>Classifying genes and proteins, where features are many and samples are few.<\/li>\n
              • <\/b>Fault detection. <\/b><\/strong>Spotting abnormal readings in industrial sensor data.<\/li>\n<\/ul>\n

                Common Mistakes to Avoid<\/b><\/strong><\/h2>\n
                  \n
                • <\/b>Not scaling the data. <\/b><\/strong>This is the number one cause of poor SVM results.<\/li>\n
                • <\/b>Judging by training accuracy. <\/b><\/strong>A high C or gamma can score near perfect on training and still fail on new data.<\/li>\n
                • <\/b>Jumping straight to a complex kernel. <\/b><\/strong>Try linear first, as it is faster and often enough.<\/li>\n
                • <\/b>Tuning C and gamma separately. <\/b><\/strong>They interact, so search them together.<\/li>\n
                • <\/b>Switching on probability without need. <\/b><\/strong>It slows training by a large margin.<\/li>\n
                • <\/b>Using SVC on huge data. <\/b><\/strong>Use LinearSVC or another model instead.<\/li>\n<\/ul>\n

                  A support vector machine draws the widest possible fence between classes, and the kernel trick lets that fence bend when it needs to. Run the program above, then try it on your own data. Scale first, start with a linear kernel, move to rbf if you need to, and tune C and gamma together with cross validation.<\/p>\n","protected":false},"excerpt":{"rendered":"

                  Support Vector Machine Tutorial for Beginners Imagine two groups of houses on opposite sides of a river, and you need to draw a fence that separates them. You could draw it anywhere in the gap, but some fences are better than others. A fence that hugs one group is risky, because a new house built […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[32,1696],"tags":[422],"class_list":["post-4797","post","type-post","status-publish","format-standard","hentry","category-machine-learning","category-machine-learning-modules","tag-support-vector-machine-tutorial-for-beginners"],"acf":[],"yoast_head":"\nSupport Vector Machine Tutorial for Beginners With Python<\/title>\n<meta name=\"description\" content=\"Learn how SVM finds the best hyperplane, what support vectors and margins are, how kernels, C and gamma work, with Python code that was tested.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Support Vector Machine Tutorial for Beginners With Python\" \/>\n<meta property=\"og:description\" content=\"Learn how SVM finds the best hyperplane, what support vectors and margins are, how kernels, C and gamma work, with Python code that was tested.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/\" \/>\n<meta property=\"og:site_name\" content=\"Prwatech\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/prwatech.in\/\" \/>\n<meta property=\"article:published_time\" content=\"2020-02-15T11:30:32+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-10-15T16:05:21+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/prwatech.in\/blog\/wp-content\/uploads\/2020\/02\/svm1.png\" \/>\n\t<meta property=\"og:image:width\" content=\"589\" \/>\n\t<meta property=\"og:image:height\" content=\"428\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Prwatech\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@Eduprwatech\" \/>\n<meta name=\"twitter:site\" content=\"@Eduprwatech\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Prwatech\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"14 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/\",\"url\":\"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/\",\"name\":\"Support Vector Machine Tutorial for Beginners With Python\",\"isPartOf\":{\"@id\":\"https:\/\/prwatech.in\/blog\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/prwatech.in\/blog\/wp-content\/uploads\/2020\/02\/svm1.png\",\"datePublished\":\"2020-02-15T11:30:32+00:00\",\"dateModified\":\"2026-10-15T16:05:21+00:00\",\"author\":{\"@id\":\"https:\/\/prwatech.in\/blog\/#\/schema\/person\/db90baff7744090b2288bbc98fea87f3\"},\"description\":\"Learn how SVM finds the best hyperplane, what support vectors and margins are, how kernels, C and gamma work, with Python code that was tested.\",\"breadcrumb\":{\"@id\":\"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/#primaryimage\",\"url\":\"https:\/\/prwatech.in\/blog\/wp-content\/uploads\/2020\/02\/svm1.png\",\"contentUrl\":\"https:\/\/prwatech.in\/blog\/wp-content\/uploads\/2020\/02\/svm1.png\",\"width\":589,\"height\":428},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/prwatech.in\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Support Vector Machine Tutorial\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/prwatech.in\/blog\/#website\",\"url\":\"https:\/\/prwatech.in\/blog\/\",\"name\":\"Prwatech\",\"description\":\"Share Ideas, Start Something Good.\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/prwatech.in\/blog\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/prwatech.in\/blog\/#\/schema\/person\/db90baff7744090b2288bbc98fea87f3\",\"name\":\"Prwatech\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/prwatech.in\/blog\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/c00bafc1b04045f31eda917de39891456c44fa47c092b9bb6be0f860a3a30a2f?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/c00bafc1b04045f31eda917de39891456c44fa47c092b9bb6be0f860a3a30a2f?s=96&d=mm&r=g\",\"caption\":\"Prwatech\"},\"url\":\"https:\/\/prwatech.in\/blog\/author\/prwatech123\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Support Vector Machine Tutorial for Beginners With Python","description":"Learn how SVM finds the best hyperplane, what support vectors and margins are, how kernels, C and gamma work, with Python code that was tested.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/","og_locale":"en_US","og_type":"article","og_title":"Support Vector Machine Tutorial for Beginners With Python","og_description":"Learn how SVM finds the best hyperplane, what support vectors and margins are, how kernels, C and gamma work, with Python code that was tested.","og_url":"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/","og_site_name":"Prwatech","article_publisher":"https:\/\/www.facebook.com\/prwatech.in\/","article_published_time":"2020-02-15T11:30:32+00:00","article_modified_time":"2026-10-15T16:05:21+00:00","og_image":[{"width":589,"height":428,"url":"https:\/\/prwatech.in\/blog\/wp-content\/uploads\/2020\/02\/svm1.png","type":"image\/png"}],"author":"Prwatech","twitter_card":"summary_large_image","twitter_creator":"@Eduprwatech","twitter_site":"@Eduprwatech","twitter_misc":{"Written by":"Prwatech","Est. reading time":"14 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/","url":"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/","name":"Support Vector Machine Tutorial for Beginners With Python","isPartOf":{"@id":"https:\/\/prwatech.in\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/#primaryimage"},"image":{"@id":"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/#primaryimage"},"thumbnailUrl":"https:\/\/prwatech.in\/blog\/wp-content\/uploads\/2020\/02\/svm1.png","datePublished":"2020-02-15T11:30:32+00:00","dateModified":"2026-10-15T16:05:21+00:00","author":{"@id":"https:\/\/prwatech.in\/blog\/#\/schema\/person\/db90baff7744090b2288bbc98fea87f3"},"description":"Learn how SVM finds the best hyperplane, what support vectors and margins are, how kernels, C and gamma work, with Python code that was tested.","breadcrumb":{"@id":"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/#primaryimage","url":"https:\/\/prwatech.in\/blog\/wp-content\/uploads\/2020\/02\/svm1.png","contentUrl":"https:\/\/prwatech.in\/blog\/wp-content\/uploads\/2020\/02\/svm1.png","width":589,"height":428},{"@type":"BreadcrumbList","@id":"https:\/\/prwatech.in\/blog\/machine-learning\/machine-learning-modules\/support-vector-machine-tutorial-for-beginners\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/prwatech.in\/blog\/"},{"@type":"ListItem","position":2,"name":"Support Vector Machine Tutorial"}]},{"@type":"WebSite","@id":"https:\/\/prwatech.in\/blog\/#website","url":"https:\/\/prwatech.in\/blog\/","name":"Prwatech","description":"Share Ideas, Start Something Good.","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/prwatech.in\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/prwatech.in\/blog\/#\/schema\/person\/db90baff7744090b2288bbc98fea87f3","name":"Prwatech","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/prwatech.in\/blog\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/c00bafc1b04045f31eda917de39891456c44fa47c092b9bb6be0f860a3a30a2f?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/c00bafc1b04045f31eda917de39891456c44fa47c092b9bb6be0f860a3a30a2f?s=96&d=mm&r=g","caption":"Prwatech"},"url":"https:\/\/prwatech.in\/blog\/author\/prwatech123\/"}]}},"_links":{"self":[{"href":"https:\/\/prwatech.in\/blog\/wp-json\/wp\/v2\/posts\/4797","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/prwatech.in\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/prwatech.in\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/prwatech.in\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/prwatech.in\/blog\/wp-json\/wp\/v2\/comments?post=4797"}],"version-history":[{"count":21,"href":"https:\/\/prwatech.in\/blog\/wp-json\/wp\/v2\/posts\/4797\/revisions"}],"predecessor-version":[{"id":12010,"href":"https:\/\/prwatech.in\/blog\/wp-json\/wp\/v2\/posts\/4797\/revisions\/12010"}],"wp:attachment":[{"href":"https:\/\/prwatech.in\/blog\/wp-json\/wp\/v2\/media?parent=4797"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/prwatech.in\/blog\/wp-json\/wp\/v2\/categories?post=4797"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/prwatech.in\/blog\/wp-json\/wp\/v2\/tags?post=4797"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}