Skip to content

SupportVectorMachine

Bases: Classifier

Support vector machine.

Parameters:

Name Type Description Default
c float

The strength of regularization. Must be strictly positive.

 1.0
kernel SupportVectorMachineKernel | None

The type of kernel to be used. Defaults to None.

 None

Raises:

Type Description
OutOfBoundsError

If c is less than or equal to 0.
Source code in src/safeds/ml/classical/classification/_support_vector_machine.py 
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
class SupportVectorMachine(Classifier):
    """
    Support vector machine.

    Parameters
    ----------
    c: float
        The strength of regularization. Must be strictly positive.
    kernel: SupportVectorMachineKernel | None
        The type of kernel to be used. Defaults to None.

    Raises
    ------
    OutOfBoundsError
        If `c` is less than or equal to 0.
    """

    def __init__(self, *, c: float = 1.0, kernel: SupportVectorMachineKernel | None = None) -> None:
        # Internal state
        self._wrapped_classifier: sk_SVC | None = None
        self._feature_names: list[str] | None = None
        self._target_name: str | None = None

        # Hyperparameters
        if c <= 0:
            raise OutOfBoundsError(c, name="c", lower_bound=OpenBound(0))
        self._c = c
        self._kernel = kernel

    @property
    def c(self) -> float:
        """
        Get the regularization strength.

        Returns
        -------
        result: float
            The regularization strength.
        """
        return self._c

    @property
    def kernel(self) -> SupportVectorMachineKernel | None:
        """
        Get the type of kernel used.

        Returns
        -------
        result: SupportVectorMachineKernel | None
            The type of kernel used.
        """
        return self._kernel

    class Kernel:
        class Linear(SupportVectorMachineKernel):
            def get_sklearn_kernel(self) -> str:
                """
                Get the name of the linear kernel.

                Returns
                -------
                result: str
                    The name of the linear kernel.
                """
                return "linear"

        class Polynomial(SupportVectorMachineKernel):
            def __init__(self, degree: int):
                if degree < 1:
                    raise OutOfBoundsError(degree, name="degree", lower_bound=ClosedBound(1))
                self._degree = degree

            def get_sklearn_kernel(self) -> str:
                """
                Get the name of the polynomial kernel.

                Returns
                -------
                result: str
                    The name of the polynomial kernel.
                """
                return "poly"

        class Sigmoid(SupportVectorMachineKernel):
            def get_sklearn_kernel(self) -> str:
                """
                Get the name of the sigmoid kernel.

                Returns
                -------
                result: str
                    The name of the sigmoid kernel.
                """
                return "sigmoid"

        class RadialBasisFunction(SupportVectorMachineKernel):
            def get_sklearn_kernel(self) -> str:
                """
                Get the name of the radial basis function (RBF) kernel.

                Returns
                -------
                result: str
                    The name of the RBF kernel.
                """
                return "rbf"

    def _get_kernel_name(self) -> str:
        """
        Get the name of the kernel.

        Returns
        -------
        result: str
            The name of the kernel.

        Raises
        ------
        TypeError
            If the kernel type is invalid.
        """
        if isinstance(self.kernel, SupportVectorMachine.Kernel.Linear):
            return "linear"
        elif isinstance(self.kernel, SupportVectorMachine.Kernel.Polynomial):
            return "poly"
        elif isinstance(self.kernel, SupportVectorMachine.Kernel.Sigmoid):
            return "sigmoid"
        elif isinstance(self.kernel, SupportVectorMachine.Kernel.RadialBasisFunction):
            return "rbf"
        else:
            raise TypeError("Invalid kernel type.")

    def fit(self, training_set: TaggedTable) -> SupportVectorMachine:
        """
        Create a copy of this classifier and fit it with the given training data.

        This classifier is not modified.

        Parameters
        ----------
        training_set : TaggedTable
            The training data containing the feature and target vectors.

        Returns
        -------
        fitted_classifier : SupportVectorMachine
            The fitted classifier.

        Raises
        ------
        LearningError
            If the training data contains invalid values or if the training failed.
        UntaggedTableError
            If the table is untagged.
        NonNumericColumnError
            If the training data contains non-numerical values.
        MissingValuesColumnError
            If the training data contains missing values.
        DatasetMissesDataError
            If the training data contains no rows.
        """
        wrapped_classifier = self._get_sklearn_classifier()
        fit(wrapped_classifier, training_set)

        result = SupportVectorMachine(c=self._c, kernel=self._kernel)
        result._wrapped_classifier = wrapped_classifier
        result._feature_names = training_set.features.column_names
        result._target_name = training_set.target.name

        return result

    def predict(self, dataset: Table) -> TaggedTable:
        """
        Predict a target vector using a dataset containing feature vectors. The model has to be trained first.

        Parameters
        ----------
        dataset : Table
            The dataset containing the feature vectors.

        Returns
        -------
        table : TaggedTable
            A dataset containing the given feature vectors and the predicted target vector.

        Raises
        ------
        ModelNotFittedError
            If the model has not been fitted yet.
        DatasetContainsTargetError
            If the dataset contains the target column already.
        DatasetMissesFeaturesError
            If the dataset misses feature columns.
        PredictionError
            If predicting with the given dataset failed.
        NonNumericColumnError
            If the dataset contains non-numerical values.
        MissingValuesColumnError
            If the dataset contains missing values.
        DatasetMissesDataError
            If the dataset contains no rows.
        """
        return predict(self._wrapped_classifier, dataset, self._feature_names, self._target_name)

    def is_fitted(self) -> bool:
        """
        Check if the classifier is fitted.

        Returns
        -------
        is_fitted : bool
            Whether the classifier is fitted.
        """
        return self._wrapped_classifier is not None

    def _get_sklearn_classifier(self) -> ClassifierMixin:
        """
        Return a new wrapped Classifier from sklearn.

        Returns
        -------
        wrapped_classifier: ClassifierMixin
            The sklearn Classifier.
        """
        return sk_SVC(C=self._c)

c: float property

Get the regularization strength.

Returns:

Name Type Description
result float

The regularization strength.

kernel: SupportVectorMachineKernel | None property

Get the type of kernel used.

Returns:

Name Type Description
result SupportVectorMachineKernel | None

The type of kernel used.

Kernel

Source code in src/safeds/ml/classical/classification/_support_vector_machine.py 
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
class Kernel:
    class Linear(SupportVectorMachineKernel):
        def get_sklearn_kernel(self) -> str:
            """
            Get the name of the linear kernel.

            Returns
            -------
            result: str
                The name of the linear kernel.
            """
            return "linear"

    class Polynomial(SupportVectorMachineKernel):
        def __init__(self, degree: int):
            if degree < 1:
                raise OutOfBoundsError(degree, name="degree", lower_bound=ClosedBound(1))
            self._degree = degree

        def get_sklearn_kernel(self) -> str:
            """
            Get the name of the polynomial kernel.

            Returns
            -------
            result: str
                The name of the polynomial kernel.
            """
            return "poly"

    class Sigmoid(SupportVectorMachineKernel):
        def get_sklearn_kernel(self) -> str:
            """
            Get the name of the sigmoid kernel.

            Returns
            -------
            result: str
                The name of the sigmoid kernel.
            """
            return "sigmoid"

    class RadialBasisFunction(SupportVectorMachineKernel):
        def get_sklearn_kernel(self) -> str:
            """
            Get the name of the radial basis function (RBF) kernel.

            Returns
            -------
            result: str
                The name of the RBF kernel.
            """
            return "rbf"

Linear

Bases: SupportVectorMachineKernel

Source code in src/safeds/ml/classical/classification/_support_vector_machine.py 
87
88
89
90
91
92
93
94
95
96
97
class Linear(SupportVectorMachineKernel):
    def get_sklearn_kernel(self) -> str:
        """
        Get the name of the linear kernel.

        Returns
        -------
        result: str
            The name of the linear kernel.
        """
        return "linear"

get_sklearn_kernel()

Get the name of the linear kernel.

Returns:

Name Type Description
result str

The name of the linear kernel.
Source code in src/safeds/ml/classical/classification/_support_vector_machine.py 
88
89
90
91
92
93
94
95
96
97
def get_sklearn_kernel(self) -> str:
    """
    Get the name of the linear kernel.

    Returns
    -------
    result: str
        The name of the linear kernel.
    """
    return "linear"

Polynomial

Bases: SupportVectorMachineKernel

Source code in src/safeds/ml/classical/classification/_support_vector_machine.py 
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
class Polynomial(SupportVectorMachineKernel):
    def __init__(self, degree: int):
        if degree < 1:
            raise OutOfBoundsError(degree, name="degree", lower_bound=ClosedBound(1))
        self._degree = degree

    def get_sklearn_kernel(self) -> str:
        """
        Get the name of the polynomial kernel.

        Returns
        -------
        result: str
            The name of the polynomial kernel.
        """
        return "poly"

__init__(degree)

Source code in src/safeds/ml/classical/classification/_support_vector_machine.py 
100
101
102
103
def __init__(self, degree: int):
    if degree < 1:
        raise OutOfBoundsError(degree, name="degree", lower_bound=ClosedBound(1))
    self._degree = degree

get_sklearn_kernel()

Get the name of the polynomial kernel.

Returns:

Name Type Description
result str

The name of the polynomial kernel.
Source code in src/safeds/ml/classical/classification/_support_vector_machine.py 
105
106
107
108
109
110
111
112
113
114
def get_sklearn_kernel(self) -> str:
    """
    Get the name of the polynomial kernel.

    Returns
    -------
    result: str
        The name of the polynomial kernel.
    """
    return "poly"

RadialBasisFunction

Bases: SupportVectorMachineKernel

Source code in src/safeds/ml/classical/classification/_support_vector_machine.py 
128
129
130
131
132
133
134
135
136
137
138
class RadialBasisFunction(SupportVectorMachineKernel):
    def get_sklearn_kernel(self) -> str:
        """
        Get the name of the radial basis function (RBF) kernel.

        Returns
        -------
        result: str
            The name of the RBF kernel.
        """
        return "rbf"

get_sklearn_kernel()

Get the name of the radial basis function (RBF) kernel.

Returns:

Name Type Description
result str

The name of the RBF kernel.
Source code in src/safeds/ml/classical/classification/_support_vector_machine.py 
129
130
131
132
133
134
135
136
137
138
def get_sklearn_kernel(self) -> str:
    """
    Get the name of the radial basis function (RBF) kernel.

    Returns
    -------
    result: str
        The name of the RBF kernel.
    """
    return "rbf"

Sigmoid

Bases: SupportVectorMachineKernel

Source code in src/safeds/ml/classical/classification/_support_vector_machine.py 
116
117
118
119
120
121
122
123
124
125
126
class Sigmoid(SupportVectorMachineKernel):
    def get_sklearn_kernel(self) -> str:
        """
        Get the name of the sigmoid kernel.

        Returns
        -------
        result: str
            The name of the sigmoid kernel.
        """
        return "sigmoid"

get_sklearn_kernel()

Get the name of the sigmoid kernel.

Returns:

Name Type Description
result str

The name of the sigmoid kernel.
Source code in src/safeds/ml/classical/classification/_support_vector_machine.py 
117
118
119
120
121
122
123
124
125
126
def get_sklearn_kernel(self) -> str:
    """
    Get the name of the sigmoid kernel.

    Returns
    -------
    result: str
        The name of the sigmoid kernel.
    """
    return "sigmoid"

__init__(*, c=1.0, kernel=None)

Source code in src/safeds/ml/classical/classification/_support_vector_machine.py 
50
51
52
53
54
55
56
57
58
59
60
def __init__(self, *, c: float = 1.0, kernel: SupportVectorMachineKernel | None = None) -> None:
    # Internal state
    self._wrapped_classifier: sk_SVC | None = None
    self._feature_names: list[str] | None = None
    self._target_name: str | None = None

    # Hyperparameters
    if c <= 0:
        raise OutOfBoundsError(c, name="c", lower_bound=OpenBound(0))
    self._c = c
    self._kernel = kernel

fit(training_set)

Create a copy of this classifier and fit it with the given training data.

This classifier is not modified.

Parameters:

Name Type Description Default
training_set TaggedTable

The training data containing the feature and target vectors.

 required

Returns:

Name Type Description
fitted_classifier SupportVectorMachine

The fitted classifier.

Raises:

Type Description
LearningError

If the training data contains invalid values or if the training failed.
UntaggedTableError

If the table is untagged.
NonNumericColumnError

If the training data contains non-numerical values.
MissingValuesColumnError

If the training data contains missing values.
DatasetMissesDataError

If the training data contains no rows.
Source code in src/safeds/ml/classical/classification/_support_vector_machine.py 
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
def fit(self, training_set: TaggedTable) -> SupportVectorMachine:
    """
    Create a copy of this classifier and fit it with the given training data.

    This classifier is not modified.

    Parameters
    ----------
    training_set : TaggedTable
        The training data containing the feature and target vectors.

    Returns
    -------
    fitted_classifier : SupportVectorMachine
        The fitted classifier.

    Raises
    ------
    LearningError
        If the training data contains invalid values or if the training failed.
    UntaggedTableError
        If the table is untagged.
    NonNumericColumnError
        If the training data contains non-numerical values.
    MissingValuesColumnError
        If the training data contains missing values.
    DatasetMissesDataError
        If the training data contains no rows.
    """
    wrapped_classifier = self._get_sklearn_classifier()
    fit(wrapped_classifier, training_set)

    result = SupportVectorMachine(c=self._c, kernel=self._kernel)
    result._wrapped_classifier = wrapped_classifier
    result._feature_names = training_set.features.column_names
    result._target_name = training_set.target.name

    return result

is_fitted()

Check if the classifier is fitted.

Returns:

Name Type Description
is_fitted bool

Whether the classifier is fitted.
Source code in src/safeds/ml/classical/classification/_support_vector_machine.py 
237
238
239
240
241
242
243
244
245
246
def is_fitted(self) -> bool:
    """
    Check if the classifier is fitted.

    Returns
    -------
    is_fitted : bool
        Whether the classifier is fitted.
    """
    return self._wrapped_classifier is not None

predict(dataset)

Predict a target vector using a dataset containing feature vectors. The model has to be trained first.

Parameters:

Name Type Description Default
dataset Table

The dataset containing the feature vectors.

 required

Returns:

Name Type Description
table TaggedTable

A dataset containing the given feature vectors and the predicted target vector.

Raises:

Type Description
ModelNotFittedError

If the model has not been fitted yet.
DatasetContainsTargetError

If the dataset contains the target column already.
DatasetMissesFeaturesError

If the dataset misses feature columns.
PredictionError

If predicting with the given dataset failed.
NonNumericColumnError

If the dataset contains non-numerical values.
MissingValuesColumnError

If the dataset contains missing values.
DatasetMissesDataError

If the dataset contains no rows.
Source code in src/safeds/ml/classical/classification/_support_vector_machine.py 
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
def predict(self, dataset: Table) -> TaggedTable:
    """
    Predict a target vector using a dataset containing feature vectors. The model has to be trained first.

    Parameters
    ----------
    dataset : Table
        The dataset containing the feature vectors.

    Returns
    -------
    table : TaggedTable
        A dataset containing the given feature vectors and the predicted target vector.

    Raises
    ------
    ModelNotFittedError
        If the model has not been fitted yet.
    DatasetContainsTargetError
        If the dataset contains the target column already.
    DatasetMissesFeaturesError
        If the dataset misses feature columns.
    PredictionError
        If predicting with the given dataset failed.
    NonNumericColumnError
        If the dataset contains non-numerical values.
    MissingValuesColumnError
        If the dataset contains missing values.
    DatasetMissesDataError
        If the dataset contains no rows.
    """
    return predict(self._wrapped_classifier, dataset, self._feature_names, self._target_name)