感知机与支持向量机（SVM）

import numpy as np
import matplotlib.pyplot as plt
# 初始数据
X = np.array([2, 2])
X1 = np.array([2, 5])
X2 = np.array([5, 5])
X3 = np.array([3, 2])
X4 = np.array([4, 4])
X5 = np.array([6, 6])

# 计算欧氏距离
d_X_X3 = np.linalg.norm(X-X3)
d_X_X1 = np.linalg.norm(X-X1)
d_X_X2 = np.linalg.norm(X-X2)

# 计算欧氏距离的平方
d_X_X3_squared = np.linalg.norm(X-X3)**2
d_X_X1_squared = np.linalg.norm(X-X1)**2
d_X_X2_squared = np.linalg.norm(X-X2)**2
d_X_X4_squared = np.linalg.norm(X-X4)**2
d_X_X5_squared = np.linalg.norm(X-X5)**2

# 输出结果
print(f"欧氏距离 d(X, X3) = {d_X_X3}< d(X, X1) = {d_X_X1}< d(X, X2) = {d_X_X2}")
print(f"欧氏距离平方 d(X, X3)^2 = {d_X_X3_squared}< d(X, X1)^2 = {d_X_X1_squared}< d(X, X2)^2 = {d_X_X2_squared}")
print(f"欧氏距离平方 d(X, X4)^2 = {d_X_X4_squared}, d(X, X5)^2 = {d_X_X5_squared}")
print(f"距离平方比较与三角不等式检验:\n"
      f"d(X, X5)^2 = {d_X_X5_squared}> d(X, X4)^2 + d(X4, X5)^2 = {d_X_X4_squared+np.linalg.norm(X4-X5)**2}")

points = [X, X1, X2, X3, X4, X5]
labels = ['X', 'X1', 'X2', 'X3', 'X4', 'X5']

plt.figure(figsize=(8, 6))
for point, label in zip(points, labels):
    plt.scatter(point[0], point[1], label=label)

# 为了直观展示距离，用线连接各点
plt.plot([X[0], X3[0]], [X[1], X3[1]], 'r--', lw=1)
plt.plot([X[0], X1[0]], [X[1], X1[1]], 'g--', lw=1)
plt.plot([X[0], X2[0]], [X[1], X2[1]], 'b--', lw=1)
plt.plot([X[0], X4[0]], [X[1], X4[1]], 'y--', lw=1)
plt.plot([X[0], X5[0]], [X[1], X5[1]], 'm--', lw=1)

# 添加图例和坐标轴标签
plt.legend()
plt.xlabel('X ')
plt.ylabel('Y ')
plt.title('点之间的欧氏距离')
plt.grid(True)
plt.show()

欧氏距离 d(X, X3) = 1.0 <d(X, X1) = 3.0 <d(X, X2) = 4.242640687119285
欧氏距离平方 d(X, X3)^2 = 1.0 <d(X, X1)^2 = 9.0 <d(X, X2)^2 = 17.999999999999996
欧氏距离平方 d(X, X4)^2 = 8.000000000000002, d(X, X5)^2 = 32.00000000000001
距离平方比较与三角不等式检验:
d(X, X5)^2 = 32.00000000000001 >d(X, X4)^2 + d(X4, X5)^2 = 16.000000000000004

C- = {X | g(X) < 0}
C+ = {X | g(X) > 0}

import numpy as np
import matplotlib.pyplot as plt

# 定义两个类别的点
class_negative = np.array([(0, 0), (2, 2)])
class_positive = np.array([(3, -3), (4, -2), (3, -1)])

# 在图上可视化这些点
plt.figure(figsize=(8, 6))
plt.scatter(class_negative[:, 0], class_negative[:, 1], color='red', label='C-')
plt.scatter(class_positive[:, 0], class_positive[:, 1], color='blue', label='C+')

# 定义并可视化分割线
# 示例中使用线性函数 g(x) = x - 3.5
x_values = np.linspace(0, 8, 100)
y_values = x_values - 3.5
plt.plot(x_values, y_values, 'g--', label='g(x) = x - 3.5')

plt.xlabel('X ')
plt.ylabel('Y ')
plt.title('两个类别的分类示例')
plt.legend()
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

# 定义类别和点
class_negative = np.array([(0, 0), (2, 2)])
class_positive = np.array([(3, -3), (4, -2), (3, -1)])
X = np.array([1, 2])
X_prime = np.array([4, 0])

# 距离函数：欧氏距离平方
def squared_euclidean_distance(x1, x2):
    return np.sum((x1-x2)**2)

# 计算 g−(X) 和 g+(X)
g_minus_X = np.min([squared_euclidean_distance(X, x) for x in class_negative])
g_plus_X = np.min([squared_euclidean_distance(X, x) for x in class_positive])
g_X = g_minus_X - g_plus_X

g_minus_X_prime = np.min([squared_euclidean_distance(X_prime, x) for x in class_negative])
g_plus_X_prime = np.min([squared_euclidean_distance(X_prime, x) for x in class_positive])
g_X_prime = g_minus_X_prime - g_plus_X_prime

# 可视化
plt.figure(figsize=(8, 6))
plt.scatter(class_negative[:, 0], class_negative[:, 1], color='red', label='C-')
plt.scatter(class_positive[:, 0], class_positive[:, 1], color='blue', label='C+')
plt.scatter(X[0], X[1], color='green', label='X (1, 2)', edgecolors='k', s=100, zorder=5)
plt.scatter(X_prime[0], X_prime[1], color="purple", label="X' (4, 0)", edgecolors="k", s=100, zorder=5)

plt.legend()
plt.xlabel('X1')
plt.ylabel('X2')
plt.title('KNN 分类示例')
plt.grid(True)

# 输出结果
print(f"g−(X) = {g_minus_X}, g+(X) = {g_plus_X}, 因此 g(X) = {g_X}, X 属于 C-")
print(f"g−(X') = {g_minus_X_prime}, g+(X') = {g_plus_X_prime}, 因此 g(X') = {g_X_prime}, X' 属于 C+")

plt.show()

g−(X) = 1, g+(X) = 13, 因此 g(X) = -12, X 属于 C-
g−(X') = 8, g+(X') = 2, 因此 g(X') = 6, X' 属于 C+

import numpy as np
import matplotlib.pyplot as plt

# 计算欧氏距离平方的函数
def squared_distance(x1, x2):
    return np.sum((x1-x2) ** 2)

# 查找 k 个最近邻的函数
def find_k_nearest_neighbors(data, labels, x, k):
    distances = np.array([squared_distance(x, point) for point in data])
    indices = np.argsort(distances)[:k]
    return labels[indices]

# 按多数投票确定类别的函数
def classify_point(k_neighbors):
    counts = np.bincount(k_neighbors)
    return np.argmax(counts)

# 可视化 k 个最近邻的函数
def plot_k_nearest_neighbors(data, labels, test_point, k):
    distances = np.array([squared_distance(test_point, point) for point in data])
    indices = np.argsort(distances)[:k]
    nearest_neighbors = data[indices]

    # 可视化邻居
    for neighbor in nearest_neighbors:
        plt.plot([test_point[0], neighbor[0]], [test_point[1], neighbor[1]], 'k--', lw=1)

# 初始数据
class_negative = np.array([(0, 0), (2, 2)])
class_positive = np.array([(3, -3), (4, -2), (3, -1)])
data = np.vstack((class_negative, class_positive))
labels = np.array([0] * len(class_negative) + [1] * len(class_positive))  # 0 - C-, 1 - C+
test_points = np.array([[1, 2], [5, 2]])

# 可视化并分类测试点
plt.figure(figsize=(8, 6))
plt.scatter(class_negative[:, 0], class_negative[:, 1], color='red', label='C-')
plt.scatter(class_positive[:, 0], class_positive[:, 1], color='blue', label='C+')

for test_point in test_points:
    plt.scatter(test_point[0], test_point[1], color='green', edgecolors='k', s=100, zorder=5)
    k_neighbors_labels = find_k_nearest_neighbors(data, labels, test_point, 3)
    classification = classify_point(k_neighbors_labels)
    print(f"点 {test_point} 被分类为 {'C-' if classification == 0 else 'C+'}")
    plot_k_nearest_neighbors(data, labels, test_point, 3)

plt.legend()
plt.xlabel('X1')
plt.ylabel('X2')
plt.title('3 近邻分类器（KNNC）')
plt.grid(True)
plt.show()

点 [1 2] 被分类为 C-
点 [5 2] 被分类为 C+

import numpy as np
import matplotlib.pyplot as plt

# 计算欧氏距离平方的函数
def squared_euclidean_distance(x1, x2):
    return np.sum((x1 - x2) ** 2)

# 定义类别及其质心
class_negative = np.array([[1, 1], [2, 2]])
class_positive = np.array([[6, 2], [7, 2], [7, 3]])
m_negative = np.mean(class_negative, axis=0)
m_positive = np.mean(class_positive, axis=0)

# 测试点
X = np.array([1, 2])
X_prime = np.array([5, 2])

# 计算测试点到质心的距离
g_minus_X = squared_euclidean_distance(X, m_negative)
g_plus_X = squared_euclidean_distance(X, m_positive)
g_X = g_minus_X - g_plus_X

g_minus_X_prime = squared_euclidean_distance(X_prime, m_negative)
g_plus_X_prime = squared_euclidean_distance(X_prime, m_positive)
g_X_prime = g_minus_X_prime - g_plus_X_prime

# 可视化
plt.figure(figsize=(8, 6))
plt.scatter(class_negative[:, 0], class_negative[:, 1], color='red', label='C-')
plt.scatter(class_positive[:, 0], class_positive[:, 1], color='blue', label='C+')
plt.scatter(X[0], X[1], color='green', label='X (1, 2)', edgecolors='k', s=100, zorder=5)
plt.scatter(X_prime[0], X_prime[1], color='purple', label="X' (5, 2)", edgecolors='k', s=100, zorder=5)
plt.scatter(m_negative[0], m_negative[1], color='red', marker='x', s=200, label='m-')
plt.scatter(m_positive[0], m_positive[1], color='blue', marker='x', s=200, label='m+')

plt.legend()
plt.xlabel('X1')
plt.ylabel('X2')
plt.title('最小距离分类器（MDC）')
plt.grid(True)
plt.show()

# 输出结果
print(f"g−(X) = {g_minus_X}, g+(X) = {g_plus_X}, hence g(X) = {g_X}, assigning X to {'C-' if g_X < 0 else 'C+'}")
print(f"g−(X') = {g_minus_X_prime}, g+(X') = {g_plus_X_prime}, hence g(X') = {g_X_prime}, assigning X' to {'C-' if g_X_prime < 0 else 'C+'}")

g−(X) = 0.5, g+(X) = 32.22222222222223, hence g(X) = -31.72222222222223, assigning X to C-
g−(X') = 12.5, g+(X') = 2.8888888888888897, hence g(X') = 9.61111111111111, assigning X' to C+

import numpy as np
import matplotlib.pyplot as plt

# 生成数据集
np.random.seed(0)
class1 = np.random.randn(100, 2) + np.array([2, 2])
class2 = np.random.randn(100, 2) + np.array([-2, -2])

# 可视化数据集
plt.scatter(class1[:, 0], class1[:, 1], color='red', label='类别 1')
plt.scatter(class2[:, 0], class2[:, 1], color='blue', label='类别 2')

# 定义权重向量和偏置
W = np.array([1, 1])
w0 = 0.5

# 绘制决策边界的函数
def draw_decision_boundary(W, w0):
    # 选择两个点来确定直线
    x_values = np.array(plt.xlim())
    y_values = -(W[0] / W[1]) * x_values - (w0 / W[1])
    plt.plot(x_values, y_values, 'k--', label='决策边界')

# 分类函数
def classify(X, W, w0):
    return np.dot(X, W) + w0

# 测试点（绿色点）
test_point = np.array([0.5, -0.5])
result = classify(test_point, W, w0)

# 可视化测试点和决策边界
draw_decision_boundary(W, w0)

plt.scatter(test_point[0], test_point[1], color='green', label='测试点')
plt.text(
    test_point[0],
    test_point[1],
    f'  分类为 {"类别 1" if result > 0 else "类别 2"}',
    color='green'
)

plt.legend()
plt.show()

import numpy as np
import matplotlib.pyplot as plt

# 生成数据集
np.random.seed(0)
N = 100  # 每个类别中的点数
r_inner = 2
r_outer = 4

# 内圆
inner_circle = r_inner * np.random.rand(N, 2)
theta = 2 * np.pi * np.random.rand(N)
inner_circle[:, 0] = r_inner * np.cos(theta)
inner_circle[:, 1] = r_inner * np.sin(theta)

# 外圆
outer_circle = r_outer * np.random.rand(N, 2)
theta = 2 * np.pi * np.random.rand(N)
outer_circle[:, 0] = r_outer * np.cos(theta)
outer_circle[:, 1] = r_outer * np.sin(theta)

# 可视化数据集
plt.figure(figsize=(8, 8))
plt.scatter(inner_circle[:, 0], inner_circle[:, 1], color='red', label='Class 1')
plt.scatter(outer_circle[:, 0], outer_circle[:, 1], color='blue', label='Class 2')

# 测试点（绿色）
test_point = np.array([3, 1])
plt.scatter(test_point[0], test_point[1], color='green', label='Test Point')

# 非线性决策边界（平均半径）
average_radius = (r_inner + r_outer) / 2
circle = plt.Circle((0, 0), average_radius, color='black', fill=False, linestyle='--', label='Decision Boundary')
plt.gca().add_artist(circle)

# 使用非线性函数进行分类
def classify_nonlinear(point):
    distance = np.sqrt(point[0] ** 2 + point[1] ** 2)
    if distance < average_radius:  # 基于距离的简单条件
        return 'Class 1'
    else:
        return 'Class 2'

# 对测试点分类
test_point_class = classify_nonlinear(test_point)
print(f"测试点被分类为: {test_point_class}")

plt.legend()
plt.show()

测试点被分类为: Class 2

import matplotlib.pyplot as plt
import numpy as np

# Генерация линейно разделимых данных
np.random.seed(0)
x1 = np.random.randn(100, 2) + np.array([-3, 3])  # Класс 1
x2 = np.random.randn(100, 2) + np.array([3, -3])  # Класс 2

# Генерация линейно неразделимых данных
theta = np.linspace(0, 2*np.pi, 100)
r = 2 + np.cos(5*theta)  # Радиальная функция для "внутреннего" класса
x_inner = np.c_[r*np.cos(theta), r*np.sin(theta)]
x_outer = np.random.randn(100, 2) * 3  # "Внешний" класс

# Визуализация
fig, axs = plt.subplots(1, 2, figsize=(12, 6))

# Линейно разделимые данные
axs[0].scatter(x1[:, 0], x1[:, 1], label='Класс 1')
axs[0].scatter(x2[:, 0], x2[:, 1], label='Класс 2')
axs[0].set_title('Линейно разделимые данные')
axs[0].legend()

# Линейно неразделимые данные
axs[1].scatter(x_inner[:, 0], x_inner[:, 1], label='Класс 1')
axs[1].scatter(x_outer[:, 0], x_outer[:, 1], label='Класс 2')
axs[1].set_title('Линейно неразделимые данные')
axs[1].legend()

plt.show()

import numpy as np
import matplotlib.pyplot as plt


def perceptron_learning_algorithm(X, Y, max_epochs=1000):
    n_samples, n_features = X.shape
    W = np.zeros(n_features)      # 用零向量初始化权重
    i = 0                         # 初始化迭代计数器
    epoch = 0                     # 记录训练轮数，避免非线性可分数据导致无限循环

    while epoch < max_epochs:
        i_old = i                 # 保存旧计数，用于检查收敛
        for k in range(n_samples):
            if np.dot(W, X[k]) * Y[k] <= 0:  # 检查是否误分类
                W = W + X[k] * Y[k]          # 更新权重
                i += 1
        if i_old == i:                       # 若本轮无更新，则收敛
            break
        epoch += 1
    return W


# 生成示例数据集
np.random.seed(42)
n_samples = 20
X_positive = np.random.randn(n_samples, 2) + [2, 3]
X_negative = np.random.randn(n_samples, 2) + [1, -2]
X = np.vstack((X_positive, X_negative))
Y = np.hstack((np.ones(n_samples), -np.ones(n_samples)))

# 添加偏置列
X_aug = np.hstack((np.ones((2 * n_samples, 1)), X))

weights = perceptron_learning_algorithm(X_aug, Y)
print("训练得到的权重：", weights)

# 可视化结果
plt.scatter(X_positive[:, 0], X_positive[:, 1], marker='o', label='类别 +1')
plt.scatter(X_negative[:, 0], X_negative[:, 1], marker='x', label='类别 -1')

x_values = np.linspace(np.min(X_aug[:, 1]), np.max(X_aug[:, 1]), 100)
y_values = -(weights[1] / weights[2]) * x_values - (weights[0] / weights[2])
plt.plot(x_values, y_values, label='分离直线')
plt.xlabel('X1')
plt.ylabel('X2')
plt.legend()
plt.grid(True)
plt.show()

import numpy as np


def update_weights(W, X, y):
    """为误分类向量 X 更新权重。"""
    return W + y * X


W = np.array([0, 0, 0])
X_samples = np.array([
    [-1, 0, 0],   # 示例 1
    [1, 0, 1],    # 示例 2
    [1, 1, 0]     # 示例 3
])
y_labels = np.array([-1, 1, 1])

for X, y in zip(X_samples, y_labels):
    prediction = np.dot(W, X)
    if (prediction <= 0 and y == 1) or (prediction > 0 and y == -1):
        W = update_weights(W, X, y)
        print(f"更新后的权重向量：{W}")

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation


class Perceptron:
    def __init__(self, learning_rate=0.01, n_iters=1000):
        self.lr = learning_rate
        self.n_iters = n_iters
        self.activation_func = self._unit_step_func
        self.weights = None
        self.bias = None
        self.weights_history = []

    def fit(self, X, y):
        n_samples, n_features = X.shape
        self.weights = np.zeros(n_features)
        self.bias = 0
        self.weights_history.append((self.weights.copy(), self.bias))
        y_ = np.array([1 if i > 0 else 0 for i in y])

        for _ in range(self.n_iters):
            for idx, x_i in enumerate(X):
                linear_output = np.dot(x_i, self.weights) + self.bias
                y_predicted = self.activation_func(linear_output)
                update = self.lr * (y_[idx] - y_predicted)
                self.weights += update * x_i
                self.bias += update
                self.weights_history.append((self.weights.copy(), self.bias))

    def _unit_step_func(self, x):
        return np.where(x > 0, 1, 0)

    def predict(self, X):
        linear_output = np.dot(X, self.weights) + self.bias
        return self.activation_func(linear_output)


def plot_decision_boundary(X, y, classifier, ax):
    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, 0.1),
                           np.arange(x2_min, x2_max, 0.1))
    Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T).reshape(xx1.shape)
    ax.contourf(xx1, xx2, Z, alpha=0.4)
    ax.scatter(X[:, 0], X[:, 1], c=y, s=10, edgecolor='k')
    weights, bias = classifier.weights_history[-1]
    ax.set_xlabel(f'权重：{weights}，偏置：{bias}')


np.random.seed(1)
X = np.random.randn(100, 2)
y = np.array([1 if x[0] + x[1] > 0 else 0 for x in X])
p = Perceptron(learning_rate=0.1, n_iters=10)
fig, ax = plt.subplots()


def update(frame):
    ax.clear()
    p.fit(X[:frame + 1], y[:frame + 1])
    plot_decision_boundary(X[:frame + 1], y[:frame + 1], p, ax)
    ax.set_title(f'迭代：{frame + 1}')


ani = FuncAnimation(fig, update, frames=range(1, X.shape[0]), interval=100)
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation


class Perceptron:
    def __init__(self, learning_rate=0.01, n_iters=1000):
        self.lr = learning_rate
        self.n_iters = n_iters
        self.activation_func = self._unit_step_func
        self.weights = None
        self.bias = None
        self.weights_history = []

    def fit(self, X, y):
        n_samples, n_features = X.shape
        self.weights = np.zeros(n_features)
        self.bias = 0
        self.weights_history.append((self.weights.copy(), self.bias))
        y_ = np.array([1 if i > 0 else 0 for i in y])

        for _ in range(self.n_iters):
            for idx, x_i in enumerate(X):
                linear_output = np.dot(x_i, self.weights) + self.bias
                y_predicted = self.activation_func(linear_output)
                error = y_[idx] - y_predicted
                self.weights += self.lr * error * x_i
                self.bias += self.lr * error
                self.weights_history.append((self.weights.copy(), self.bias))

    def _unit_step_func(self, x):
        return np.where(x > 0, 1, 0)

    def predict(self, X):
        linear_output = np.dot(X, self.weights) + self.bias
        return self.activation_func(linear_output)

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation


class Perceptron:
    def __init__(self, learning_rate=0.01, n_iters=1000):
        self.lr = learning_rate
        self.n_iters = n_iters
        self.activation_func = self._unit_step_func
        self.weights = None
        self.bias = None
        self.weights_history = []

    def fit(self, X, y):
        n_samples, n_features = X.shape
        self.weights = np.zeros(n_features)
        self.bias = 0
        self.weights_history.append((self.weights.copy(), self.bias))
        y_ = np.array([1 if i > 0 else 0 for i in y])
        for _ in range(self.n_iters):
            for idx, x_i in enumerate(X):
                linear_output = np.dot(x_i, self.weights) + self.bias
                y_predicted = self.activation_func(linear_output)
                update = self.lr * (y_[idx] - y_predicted)
                self.weights += update * x_i
                self.bias += update
                self.weights_history.append((self.weights.copy(), self.bias))

    def _unit_step_func(self, x):
        return np.where(x > 0, 1, 0)

    def predict(self, X):
        linear_output = np.dot(X, self.weights) + self.bias
        return self.activation_func(linear_output)


def add_nonlinear_features(X):
    X_nonlinear = np.zeros((X.shape[0], X.shape[1] * 3))
    X_nonlinear[:, :2] = X
    X_nonlinear[:, 2] = X[:, 0] ** 2
    X_nonlinear[:, 3] = X[:, 1] ** 2
    X_nonlinear[:, 4] = X[:, 0] * X[:, 1]
    return X_nonlinear


def plot_decision_boundary(X, y, classifier, ax):
    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, 0.1),
                           np.arange(x2_min, x2_max, 0.1))
    grid = np.array([xx1.ravel(), xx2.ravel()]).T
    Z = classifier.predict(add_nonlinear_features(grid)).reshape(xx1.shape)
    ax.contourf(xx1, xx2, Z, alpha=0.4)
    ax.scatter(X[:, 0], X[:, 1], c=y, s=10, edgecolor='k')
    weights, bias = classifier.weights_history[-1]
    ax.set_xlabel(f'权重：{weights}，偏置：{bias}')


np.random.seed(1)
X = np.random.randn(100, 2)
y = np.array([1 if x[0] ** 2 + x[1] ** 2 < 1 else 0 for x in X])
X_nonlinear = add_nonlinear_features(X)
p = Perceptron(learning_rate=0.1, n_iters=10)
p.fit(X_nonlinear, y)

fig, ax = plt.subplots()
plot_decision_boundary(X, y, p, ax)
plt.show()

# 两个变量上的异或函数

def xor(x1, x2):
    return (x1 and not x2) or (not x1 and x2)


# 检查 XOR 的置换不变性
a = 0
b = 1
result1 = xor(a, b)
result2 = xor(b, a)


# XOR 的正正规形式（PNF）
def xor_pnf(x1, x2):
    return (1 - x1) * x2 + x1 * (1 - x2)


pnf_result1 = xor_pnf(a, b)
pnf_result2 = xor_pnf(b, a)
print(result1, result2, pnf_result1, pnf_result2)

1 True 1 1

X = [[3, 3], [3, 4], [2, 3], [1, 1], [1, 3], [2, 2]]
y = [1, 1, 1, -1, -1, -1]

from sklearn import svm
import numpy as np
import matplotlib.pyplot as plt

X = np.array([
    [3, 3],
    [3, 4],
    [2, 3],
    [1, 1],
    [1, 3],
    [2, 2]
])
y = np.array([1, 1, 1, -1, -1, -1])

clf = svm.SVC(kernel='linear', C=1.0)
clf.fit(X, y)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()

xx = np.linspace(xlim[0], xlim[1], 30)
yy = np.linspace(ylim[0], ylim[1], 30)
YY, XX = np.meshgrid(yy, xx)
xy = np.vstack([XX.ravel(), YY.ravel()]).T
Z = clf.decision_function(xy).reshape(XX.shape)

ax.contour(XX, YY, Z, colors='k', levels=[-1, 0, 1], alpha=0.5,
           linestyles=['--', '-', '--'])
ax.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1], s=100,
           linewidth=1, facecolors='none', edgecolors='k')
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm

xx, yy = np.meshgrid(np.linspace(-3, 3, 500),
                     np.linspace(-3, 3, 500))
np.random.seed(0)
X = np.random.randn(300, 2)
Y = np.logical_xor(X[:, 0] > 0, X[:, 1] > 0)

clf = svm.NuSVC()
clf.fit(X, Y)

Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.imshow(Z, interpolation='nearest',
           extent=(xx.min(), xx.max(), yy.min(), yy.max()),
           aspect='auto', origin='lower', cmap=plt.cm.BuGn)
plt.contour(xx, yy, Z, levels=[0], linewidths=2)
plt.scatter(X[:, 0], X[:, 1], s=30, c=Y, cmap=plt.cm.jet)
plt.xticks(())
plt.yticks(())
plt.axis([-3, 3, -3, 3])
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm, datasets


def make_meshgrid(x, y, h=.02):
    x_min, x_max = x.min() - 1, x.max() + 1
    y_min, y_max = y.min() - 1, y.max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                         np.arange(y_min, y_max, h))
    return xx, yy


def plot_contours(ax, clf, xx, yy, **params):
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    out = ax.contourf(xx, yy, Z, **params)
    return out


iris = datasets.load_iris()
X = iris.data[:, :2]
y = iris.target
C = 1.0

models = (
    svm.SVC(kernel='linear', C=C),
    svm.LinearSVC(C=C, max_iter=10000),
    svm.SVC(kernel='rbf', gamma=0.7, C=C),
    svm.SVC(kernel='poly', degree=3, gamma='auto', C=C)
)
models = (clf.fit(X, y) for clf in models)

titles = (
    '线性核 SVC',
    'LinearSVC（线性核）',
    'RBF 核 SVC',
    '多项式核 SVC（三次）'
)

fig, sub = plt.subplots(2, 2, figsize=(10, 8))
plt.subplots_adjust(wspace=0.2, hspace=0.2)

X0, X1 = X[:, 0], X[:, 1]
xx, yy = make_meshgrid(X0, X1)

for clf, title, ax in zip(models, titles, sub.flatten()):
    plot_contours(ax, clf, xx, yy, cmap='winter', alpha=0.8)
    ax.scatter(X0, X1, c=y, cmap=plt.cm.Greys, s=40, edgecolors='w')
    ax.set_xlim(xx.min(), xx.max())
    ax.set_ylim(yy.min(), yy.max())
    ax.set_xlabel('萼片长度')
    ax.set_ylabel('萼片宽度')
    ax.set_xticks(())
    ax.set_yticks(())
    ax.set_title(title)

plt.show()