17.1. Trenowanie klasyfikatora liniowego

# Wczytanie bibliotek.
from sklearn.svm import LinearSVC
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
import numpy as np

# Wczytanie danych zawierających tylko dwie klasy i dwie cechy.
iris = datasets.load_iris()
features = iris.data[:100,:2]
target = iris.target[:100]

# Standaryzowanie cech.
scaler = StandardScaler()
features_standardized = scaler.fit_transform(features)

# Utworzenie klasyfikatora wektora nośnego.
svc = LinearSVC(C=1.0)

# Wytrenowanie modelu.
model = svc.fit(features_standardized, target)





# Wczytanie biblioteki.
from matplotlib import pyplot as plt

# Umieszczenie na wykresie punktów danych w kolorach wybranych na podstawie ich klas.
color = ["black" if c == 0 else "lightgrey" for c in target]
plt.scatter(features_standardized[:,0], features_standardized[:,1], c=color)

# Utworzenie hiperpłaszczyzny.
w = svc.coef_[0]
a = -w[0] / w[1]
xx = np.linspace(-2.5, 2.5)
yy = a * xx - (svc.intercept_[0]) / w[1]

# Wyświetlenie hiperpłaszczyzny.
plt.plot(xx, yy)
plt.axis("off"), plt.show();





# Utworzenie nowej obserwacji.
new_observation = [[ -2,  3]]

# Prognozowanie klasy nowej obserwacji.
svc.predict(new_observation)

array([0])





17.2. Obsługa liniowo nierozdzielnych klas przy użyciu funkcji jądra

# Wczytanie bibliotek.
from sklearn.svm import SVC
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
import numpy as np

# Zdefiniowanie wartości zalążka.
np.random.seed(0)

# Wygenerowanie dwóch cech.
features = np.random.randn(200, 2)

# Użycie bramki XOR (nie musisz wiedzieć, co to jest) do wygenerowania
# liniowo nierozdzielnych klas.
target_xor = np.logical_xor(features[:, 0] > 0, features[:, 1] > 0)
target = np.where(target_xor, 0, 1)

# Utworzenie maszyny wektora nośnego z jądrem radialnej funkcji bazowej.
svc = SVC(kernel="rbf", random_state=0, gamma=1, C=1)

# Wytrenowanie klasyfikatora.
model = svc.fit(features, target)





# Wyświetlenie obserwacji i hiperpłaszczyzny granicy decyzyjnej.
from matplotlib.colors import ListedColormap
import matplotlib.pyplot as plt

def plot_decision_regions(X, y, classifier):
    cmap = ListedColormap(("red", "blue"))
    xx1, xx2 = np.meshgrid(np.arange(-3, 3, 0.02), np.arange(-3, 3, 0.02))
    Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
    Z = Z.reshape(xx1.shape)
    plt.contourf(xx1, xx2, Z, alpha=0.1, cmap=cmap)

    for idx, cl in enumerate(np.unique(y)):
        plt.scatter(x=X[y == cl, 0], y=X[y == cl, 1],
                    alpha=0.8, c=cmap(idx),
                    marker="+", label=cl)





# Utworzenie klasyfikatora wektora nośnego z jądrem liniowym.
svc_linear = SVC(kernel="linear", random_state=0, C=1)

# Wytrenowanie modelu.
svc_linear.fit(features, target)

SVC(C=1, kernel='linear', random_state=0)





# Wyświetlenie obserwacji i hiperpłaszczyzny.
plot_decision_regions(features, target, classifier=svc_linear)
plt.axis("off"), plt.show();





# Utworzenie maszyny wektora nośnego z jądrem radialnej funkcji bazowej.
svc = SVC(kernel="rbf", random_state=0, gamma=1, C=1)

# Wytrenowanie klasyfikatora.
model = svc.fit(features, target)





# Wyświetlenie obserwacji i hiperpłaszczyzny.
plot_decision_regions(features, target, classifier=svc)
plt.axis("off"), plt.show();





17.3. Określanie prognozowanego prawdopodobieństwa

# Wczytanie bibliotek.
from sklearn.svm import SVC
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
import numpy as np

# Wczytanie danych.
iris = datasets.load_iris()
features = iris.data
target = iris.target

# Standaryzowanie cech.
scaler = StandardScaler()
features_standardized = scaler.fit_transform(features)

# Utworzenie obiektu klasyfikatora wektora nośnego.
svc = SVC(kernel="linear", probability=True, random_state=0)

# Wytrenowanie klasyfikatora.
model = svc.fit(features_standardized, target)

# Utworzenie nowej obserwacji.
new_observation = [[.4, .4, .4, .4]]

# Wyświetlenie prawdopodobieństwa prognozy.
model.predict_proba(new_observation)

array([[0.00541761, 0.97348825, 0.02109414]])





17.4. Identyfikacja wektorów nośnych

# Wczytanie bibliotek.
from sklearn.svm import SVC
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
import numpy as np

#Wczytanie danych zawierających tylko dwie klasy.
iris = datasets.load_iris()
features = iris.data[:100,:]
target = iris.target[:100]

# Standaryzowanie cech.
scaler = StandardScaler()
features_standardized = scaler.fit_transform(features)

# Utworzenie obiektu klasyfikatora wektora nośnego.
svc = SVC(kernel="linear", random_state=0)

# Wytrenowanie klasyfikatora.
model = svc.fit(features_standardized, target)

# Wyświetlenie wektorów nośnych.
model.support_vectors_

array([[-0.5810659 ,  0.42196824, -0.80497402, -0.50860702],
           [-1.52079513, -1.67737625, -1.08231219, -0.86427627],
           [-0.89430898, -1.4674418 ,  0.30437864,  0.38056609],
           [-0.5810659 , -1.25750735,  0.09637501,  0.55840072]])





model.support_

array([23, 41, 57, 98], dtype=int32)





model.n_support_

array([2, 2], dtype=int32)





17.5. Obsługa niezrównoważonych klas

# Wczytanie bibliotek.
from sklearn.svm import SVC
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
import numpy as np

#Wczytanie danych zawierających tylko dwie klasy.
iris = datasets.load_iris()
features = iris.data[:100,:]
target = iris.target[:100]

# Zdefiniowanie klasy jako wysoce niezrównoważonej przez usunięcie pierwszych 40 obserwacji.
features = features[40:,:]
target = target[40:]

# Utworzenie wektora docelowego wskazującego, czy obserwacja jest klasy 0, czy 1.
target = np.where((target == 0), 0, 1)

# Standaryzowanie cech.
scaler = StandardScaler()
features_standardized = scaler.fit_transform(features)

# Utworzenie klasyfikatora wektora nośnego.
svc = SVC(kernel="linear", class_weight="balanced", C=1.0, random_state=0)

# Wytrenowanie klasyfikatora.
model = svc.fit(features_standardized, target)
