.. DO NOT EDIT.
.. THIS FILE WAS AUTOMATICALLY GENERATED BY SPHINX-GALLERY.
.. TO MAKE CHANGES, EDIT THE SOURCE PYTHON FILE:
.. "auto_examples/applications/svm_gui.py"
.. LINE NUMBERS ARE GIVEN BELOW.

.. only:: html

    .. note::
        :class: sphx-glr-download-link-note

        :ref:`Go to the end <sphx_glr_download_auto_examples_applications_svm_gui.py>`
        to download the full example code or to run this example in your browser via JupyterLite or Binder

.. rst-class:: sphx-glr-example-title

.. _sphx_glr_auto_examples_applications_svm_gui.py:


==========
Libsvm GUI
==========

A simple graphical frontend for Libsvm mainly intended for didactic
purposes. You can create data points by point and click and visualize
the decision region induced by different kernels and parameter settings.

To create positive examples click the left mouse button; to create
negative examples click the right button.

If all examples are from the same class, it uses a one-class SVM.

.. GENERATED FROM PYTHON SOURCE LINES 16-384

.. code-block:: Python


    # Author: Peter Prettenhoer <peter.prettenhofer@gmail.com>
    #
    # License: BSD 3 clause

    import matplotlib

    matplotlib.use("TkAgg")
    from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg

    try:
        from matplotlib.backends.backend_tkagg import NavigationToolbar2Tk
    except ImportError:
        # NavigationToolbar2TkAgg was deprecated in matplotlib 2.2
        from matplotlib.backends.backend_tkagg import (
            NavigationToolbar2TkAgg as NavigationToolbar2Tk,
        )
    import sys
    import tkinter as Tk

    import numpy as np
    from matplotlib.contour import ContourSet
    from matplotlib.figure import Figure

    from sklearn import svm
    from sklearn.datasets import dump_svmlight_file

    y_min, y_max = -50, 50
    x_min, x_max = -50, 50


    class Model:
        """The Model which hold the data. It implements the
        observable in the observer pattern and notifies the
        registered observers on change event.
        """

        def __init__(self):
            self.observers = []
            self.surface = None
            self.data = []
            self.cls = None
            self.surface_type = 0

        def changed(self, event):
            """Notify the observers."""
            for observer in self.observers:
                observer.update(event, self)

        def add_observer(self, observer):
            """Register an observer."""
            self.observers.append(observer)

        def set_surface(self, surface):
            self.surface = surface

        def dump_svmlight_file(self, file):
            data = np.array(self.data)
            X = data[:, 0:2]
            y = data[:, 2]
            dump_svmlight_file(X, y, file)


    class Controller:
        def __init__(self, model):
            self.model = model
            self.kernel = Tk.IntVar()
            self.surface_type = Tk.IntVar()
            # Whether or not a model has been fitted
            self.fitted = False

        def fit(self):
            print("fit the model")
            train = np.array(self.model.data)
            X = train[:, 0:2]
            y = train[:, 2]

            C = float(self.complexity.get())
            gamma = float(self.gamma.get())
            coef0 = float(self.coef0.get())
            degree = int(self.degree.get())
            kernel_map = {0: "linear", 1: "rbf", 2: "poly"}
            if len(np.unique(y)) == 1:
                clf = svm.OneClassSVM(
                    kernel=kernel_map[self.kernel.get()],
                    gamma=gamma,
                    coef0=coef0,
                    degree=degree,
                )
                clf.fit(X)
            else:
                clf = svm.SVC(
                    kernel=kernel_map[self.kernel.get()],
                    C=C,
                    gamma=gamma,
                    coef0=coef0,
                    degree=degree,
                )
                clf.fit(X, y)
            if hasattr(clf, "score"):
                print("Accuracy:", clf.score(X, y) * 100)
            X1, X2, Z = self.decision_surface(clf)
            self.model.clf = clf
            self.model.set_surface((X1, X2, Z))
            self.model.surface_type = self.surface_type.get()
            self.fitted = True
            self.model.changed("surface")

        def decision_surface(self, cls):
            delta = 1
            x = np.arange(x_min, x_max + delta, delta)
            y = np.arange(y_min, y_max + delta, delta)
            X1, X2 = np.meshgrid(x, y)
            Z = cls.decision_function(np.c_[X1.ravel(), X2.ravel()])
            Z = Z.reshape(X1.shape)
            return X1, X2, Z

        def clear_data(self):
            self.model.data = []
            self.fitted = False
            self.model.changed("clear")

        def add_example(self, x, y, label):
            self.model.data.append((x, y, label))
            self.model.changed("example_added")

            # update decision surface if already fitted.
            self.refit()

        def refit(self):
            """Refit the model if already fitted."""
            if self.fitted:
                self.fit()


    class View:
        """Test docstring."""

        def __init__(self, root, controller):
            f = Figure()
            ax = f.add_subplot(111)
            ax.set_xticks([])
            ax.set_yticks([])
            ax.set_xlim((x_min, x_max))
            ax.set_ylim((y_min, y_max))
            canvas = FigureCanvasTkAgg(f, master=root)
            try:
                canvas.draw()
            except AttributeError:
                # support for matplotlib (1.*)
                canvas.show()
            canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
            canvas._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
            canvas.mpl_connect("button_press_event", self.onclick)
            toolbar = NavigationToolbar2Tk(canvas, root)
            toolbar.update()
            self.controllbar = ControllBar(root, controller)
            self.f = f
            self.ax = ax
            self.canvas = canvas
            self.controller = controller
            self.contours = []
            self.c_labels = None
            self.plot_kernels()

        def plot_kernels(self):
            self.ax.text(-50, -60, "Linear: $u^T v$")
            self.ax.text(-20, -60, r"RBF: $\exp (-\gamma \| u-v \|^2)$")
            self.ax.text(10, -60, r"Poly: $(\gamma \, u^T v + r)^d$")

        def onclick(self, event):
            if event.xdata and event.ydata:
                if event.button == 1:
                    self.controller.add_example(event.xdata, event.ydata, 1)
                elif event.button == 3:
                    self.controller.add_example(event.xdata, event.ydata, -1)

        def update_example(self, model, idx):
            x, y, l = model.data[idx]
            if l == 1:
                color = "w"
            elif l == -1:
                color = "k"
            self.ax.plot([x], [y], "%so" % color, scalex=0.0, scaley=0.0)

        def update(self, event, model):
            if event == "examples_loaded":
                for i in range(len(model.data)):
                    self.update_example(model, i)

            if event == "example_added":
                self.update_example(model, -1)

            if event == "clear":
                self.ax.clear()
                self.ax.set_xticks([])
                self.ax.set_yticks([])
                self.contours = []
                self.c_labels = None
                self.plot_kernels()

            if event == "surface":
                self.remove_surface()
                self.plot_support_vectors(model.clf.support_vectors_)
                self.plot_decision_surface(model.surface, model.surface_type)

            self.canvas.draw()

        def remove_surface(self):
            """Remove old decision surface."""
            if len(self.contours) > 0:
                for contour in self.contours:
                    if isinstance(contour, ContourSet):
                        for lineset in contour.collections:
                            lineset.remove()
                    else:
                        contour.remove()
                self.contours = []

        def plot_support_vectors(self, support_vectors):
            """Plot the support vectors by placing circles over the
            corresponding data points and adds the circle collection
            to the contours list."""
            cs = self.ax.scatter(
                support_vectors[:, 0],
                support_vectors[:, 1],
                s=80,
                edgecolors="k",
                facecolors="none",
            )
            self.contours.append(cs)

        def plot_decision_surface(self, surface, type):
            X1, X2, Z = surface
            if type == 0:
                levels = [-1.0, 0.0, 1.0]
                linestyles = ["dashed", "solid", "dashed"]
                colors = "k"
                self.contours.append(
                    self.ax.contour(X1, X2, Z, levels, colors=colors, linestyles=linestyles)
                )
            elif type == 1:
                self.contours.append(
                    self.ax.contourf(
                        X1, X2, Z, 10, cmap=matplotlib.cm.bone, origin="lower", alpha=0.85
                    )
                )
                self.contours.append(
                    self.ax.contour(X1, X2, Z, [0.0], colors="k", linestyles=["solid"])
                )
            else:
                raise ValueError("surface type unknown")


    class ControllBar:
        def __init__(self, root, controller):
            fm = Tk.Frame(root)
            kernel_group = Tk.Frame(fm)
            Tk.Radiobutton(
                kernel_group,
                text="Linear",
                variable=controller.kernel,
                value=0,
                command=controller.refit,
            ).pack(anchor=Tk.W)
            Tk.Radiobutton(
                kernel_group,
                text="RBF",
                variable=controller.kernel,
                value=1,
                command=controller.refit,
            ).pack(anchor=Tk.W)
            Tk.Radiobutton(
                kernel_group,
                text="Poly",
                variable=controller.kernel,
                value=2,
                command=controller.refit,
            ).pack(anchor=Tk.W)
            kernel_group.pack(side=Tk.LEFT)

            valbox = Tk.Frame(fm)
            controller.complexity = Tk.StringVar()
            controller.complexity.set("1.0")
            c = Tk.Frame(valbox)
            Tk.Label(c, text="C:", anchor="e", width=7).pack(side=Tk.LEFT)
            Tk.Entry(c, width=6, textvariable=controller.complexity).pack(side=Tk.LEFT)
            c.pack()

            controller.gamma = Tk.StringVar()
            controller.gamma.set("0.01")
            g = Tk.Frame(valbox)
            Tk.Label(g, text="gamma:", anchor="e", width=7).pack(side=Tk.LEFT)
            Tk.Entry(g, width=6, textvariable=controller.gamma).pack(side=Tk.LEFT)
            g.pack()

            controller.degree = Tk.StringVar()
            controller.degree.set("3")
            d = Tk.Frame(valbox)
            Tk.Label(d, text="degree:", anchor="e", width=7).pack(side=Tk.LEFT)
            Tk.Entry(d, width=6, textvariable=controller.degree).pack(side=Tk.LEFT)
            d.pack()

            controller.coef0 = Tk.StringVar()
            controller.coef0.set("0")
            r = Tk.Frame(valbox)
            Tk.Label(r, text="coef0:", anchor="e", width=7).pack(side=Tk.LEFT)
            Tk.Entry(r, width=6, textvariable=controller.coef0).pack(side=Tk.LEFT)
            r.pack()
            valbox.pack(side=Tk.LEFT)

            cmap_group = Tk.Frame(fm)
            Tk.Radiobutton(
                cmap_group,
                text="Hyperplanes",
                variable=controller.surface_type,
                value=0,
                command=controller.refit,
            ).pack(anchor=Tk.W)
            Tk.Radiobutton(
                cmap_group,
                text="Surface",
                variable=controller.surface_type,
                value=1,
                command=controller.refit,
            ).pack(anchor=Tk.W)

            cmap_group.pack(side=Tk.LEFT)

            train_button = Tk.Button(fm, text="Fit", width=5, command=controller.fit)
            train_button.pack()
            fm.pack(side=Tk.LEFT)
            Tk.Button(fm, text="Clear", width=5, command=controller.clear_data).pack(
                side=Tk.LEFT
            )


    def get_parser():
        from optparse import OptionParser

        op = OptionParser()
        op.add_option(
            "--output",
            action="store",
            type="str",
            dest="output",
            help="Path where to dump data.",
        )
        return op


    def main(argv):
        op = get_parser()
        opts, args = op.parse_args(argv[1:])
        root = Tk.Tk()
        model = Model()
        controller = Controller(model)
        root.wm_title("Scikit-learn Libsvm GUI")
        view = View(root, controller)
        model.add_observer(view)
        Tk.mainloop()

        if opts.output:
            model.dump_svmlight_file(opts.output)


    if __name__ == "__main__":
        main(sys.argv)


.. _sphx_glr_download_auto_examples_applications_svm_gui.py:

.. only:: html

  .. container:: sphx-glr-footer sphx-glr-footer-example

    .. container:: binder-badge

      .. image:: images/binder_badge_logo.svg
        :target: https://mybinder.org/v2/gh/scikit-learn/scikit-learn/main?urlpath=lab/tree/notebooks/auto_examples/applications/svm_gui.ipynb
        :alt: Launch binder
        :width: 150 px

    .. container:: lite-badge

      .. image:: images/jupyterlite_badge_logo.svg
        :target: ../../lite/lab/?path=auto_examples/applications/svm_gui.ipynb
        :alt: Launch JupyterLite
        :width: 150 px

    .. container:: sphx-glr-download sphx-glr-download-jupyter

      :download:`Download Jupyter notebook: svm_gui.ipynb <svm_gui.ipynb>`

    .. container:: sphx-glr-download sphx-glr-download-python

      :download:`Download Python source code: svm_gui.py <svm_gui.py>`


.. include:: svm_gui.recommendations


.. only:: html

 .. rst-class:: sphx-glr-signature

    `Gallery generated by Sphinx-Gallery <https://sphinx-gallery.github.io>`_